Refactoring of chrome speech recognition architecture (CL1.6)

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 37 matching lines @@
 
 const char kUtteranceKey[] = "utterance";
 const char kConfidenceKey[] = "confidence";
 const char kHypothesesKey[] = "hypotheses";
 
 const char kOnErrorEvent[] = "experimental.speechInput.onError";
 const char kOnResultEvent[] = "experimental.speechInput.onResult";
 const char kOnSoundStartEvent[] = "experimental.speechInput.onSoundStart";
 const char kOnSoundEndEvent[] = "experimental.speechInput.onSoundEnd";
 
-// Caller id provided to the speech recognizer. Since only one extension can
+// Session id provided to the speech recognizer. Since only one extension can
 // be recording on the same time a constant value is enough as id.
-static const int kSpeechCallerId = 1;
+// TODO(primiano) this will not be valid anymore once speech input extension

[Satish, 2012/04/17 09:25:43]

'valid anymore' -> 'required'
'extension will use' -> 'extension API uses'

+// will use the SpeechRecognitionManager and not the SpeechRecognizer directly.
+static const int kSpeechInputSessionId = 1;
 
 // Wrap an SpeechInputExtensionManager using scoped_refptr to avoid
 // assertion failures on destruction because of not using release().
 class SpeechInputExtensionManagerWrapper : public ProfileKeyedService {
  public:
   explicit SpeechInputExtensionManagerWrapper(
       SpeechInputExtensionManager* manager)
       : manager_(manager) {}
 
   virtual ~SpeechInputExtensionManagerWrapper() {}
@@ skipping 161 matching lines @@
   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::OnRecognitionResult(
-    int caller_id,
+    int session_id,
     const content::SpeechRecognitionResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
 
   // 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,
       base::Bind(&SpeechInputExtensionManager::SetRecognitionResultOnUIThread,
       this, result, extension_id));
 }
@@ skipping 21 matching lines @@
     js_hypothesis_object->SetDouble(kConfidenceKey,
         hypothesis.confidence);
   }
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
   VLOG(1) << "Results: " << json_args;
   DispatchEventToExtension(extension_id, kOnResultEvent, json_args);
 }
 
-void SpeechInputExtensionManager::OnRecognitionStart(int caller_id) {
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+void SpeechInputExtensionManager::OnRecognitionStart(int session_id) {
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
 }
 
-void SpeechInputExtensionManager::OnAudioStart(int caller_id) {
+void SpeechInputExtensionManager::OnAudioStart(int session_id) {
   VLOG(1) << "OnAudioStart";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::DidStartReceivingAudioOnUIThread,
       this));
 }
 
-void SpeechInputExtensionManager::OnAudioEnd(int caller_id) {
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+void SpeechInputExtensionManager::OnAudioEnd(int session_id) {
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
 }
 
-void SpeechInputExtensionManager::OnRecognitionEnd(int caller_id) {
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+void SpeechInputExtensionManager::OnRecognitionEnd(int session_id) {
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
 }
 
 void SpeechInputExtensionManager::DidStartReceivingAudioOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
   DCHECK_EQ(state_, kStarting);
@@ skipping 17 matching lines @@
   }
 
   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::OnRecognitionError(
-    int caller_id, const content::SpeechRecognitionError& error) {
+    int session_id, const content::SpeechRecognitionError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
   VLOG(1) << "OnRecognitionError: " << error.code;
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
   // Release the recognizer object.
   GetSpeechInputExtensionInterface()->StopRecording(true);
 
   std::string event_error_code;
@@ skipping 37 matching lines @@
   }
 
   if (!event_error_code.empty()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&SpeechInputExtensionManager::DispatchError,
         this, event_error_code, report_to_event));
   }
 }
 
 void SpeechInputExtensionManager::OnEnvironmentEstimationComplete(
-    int caller_id) {
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+    int session_id) {
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
 }
 
-void SpeechInputExtensionManager::OnSoundStart(int caller_id) {
+void SpeechInputExtensionManager::OnSoundStart(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
   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::OnSoundEnd(int caller_id) {
+void SpeechInputExtensionManager::OnSoundEnd(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
   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(
@@ skipping 125 matching lines @@
   }
 
   if (GetSpeechInputExtensionInterface()->IsCapturingAudio()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&SpeechInputExtensionManager::DispatchError, this,
         std::string(kErrorRecordingDeviceInUse), false));
     return;
   }
 
   GetSpeechInputExtensionInterface()->StartRecording(
-      this, context_getter, kSpeechCallerId, language, grammar,
+      this, context_getter, kSpeechInputSessionId, language, grammar,
       filter_profanities);
 }
 
 bool SpeechInputExtensionManager::HasAudioInputDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return SpeechRecognitionManager::GetInstance()->HasAudioInputDevices();
 }
 
 bool SpeechInputExtensionManager::IsCapturingAudio() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 23 matching lines @@
 void SpeechInputExtensionManager::IsRecordingOnUIThread(
     const IsRecordingCallback& callback,
     bool result) {
   BrowserThread::CurrentlyOn(BrowserThread::UI);
   callback.Run(result);
 }
 
 void SpeechInputExtensionManager::StartRecording(
     content::SpeechRecognitionEventListener* listener,
     net::URLRequestContextGetter* context_getter,
-    int caller_id,
+    int session_id,
     const std::string& language,
     const std::string& grammar,
     bool filter_profanities) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!recognizer_);
   recognizer_ = content::SpeechRecognizer::Create(
-      listener, caller_id, language, grammar, context_getter,
+      listener, session_id, language, grammar, context_getter,
       filter_profanities, "", "");
   recognizer_->StartRecognition();
 }
 
 bool SpeechInputExtensionManager::HasValidRecognizer() {
   return !!recognizer_;
 }
 
 bool SpeechInputExtensionManager::Stop(const std::string& extension_id,
     std::string* error) {
@@ skipping 76 matching lines @@
   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::OnAudioLevelsChange(int caller_id,
-                                                      float volume,
-                                                      float noise_volume) {
-  DCHECK_EQ(caller_id, kSpeechCallerId);
+void SpeechInputExtensionManager::OnAudioLevelsChange(int session_id,
+                                                       float volume,
+                                                       float noise_volume) {
+  DCHECK_EQ(session_id, kSpeechInputSessionId);
   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);
 }