SpeechInputExtensionManager now interface with SpeechRecognitionManagerDelegate

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"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/profiles/profile_keyed_service_factory.h"
-#include "chrome/browser/speech/speech_recognition_tray_icon_controller.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/speech_recognition_manager.h"
-#include "content/public/browser/speech_recognizer.h"
+#include "content/public/browser/speech_recognition_session_config.h"
+#include "content/public/browser/speech_recognition_session_context.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
+#include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 using content::SpeechRecognitionHypothesis;
 using content::SpeechRecognitionManager;
 
 namespace {
 
 const char kErrorNoRecordingDeviceFound[] = "noRecordingDeviceFound";
 const char kErrorRecordingDeviceInUse[] = "recordingDeviceInUse";
 const char kErrorUnableToStart[] = "unableToStart";
 const char kErrorRequestDenied[] = "requestDenied";
 const char kErrorRequestInProgress[] = "requestInProgress";
 const char kErrorInvalidOperation[] = "invalidOperation";
 
 const char kErrorCodeKey[] = "code";
 const char kErrorCaptureError[] = "captureError";
 const char kErrorNetworkError[] = "networkError";
 const char kErrorNoSpeechHeard[] = "noSpeechHeard";
 const char kErrorNoResults[] = "noResults";
 
 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";
 
-// 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.
-// TODO(primiano) this will not be valid anymore once speech input extension
-// 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 76 matching lines @@
 SpeechInputExtensionInterface::SpeechInputExtensionInterface() {
 }
 
 SpeechInputExtensionInterface::~SpeechInputExtensionInterface() {
 }
 
 SpeechInputExtensionManager::SpeechInputExtensionManager(Profile* profile)
     : profile_(profile),
       state_(kIdle),
       registrar_(new content::NotificationRegistrar),
-      speech_interface_(NULL) {
+      speech_interface_(NULL),
+      is_recognition_in_progress_(false),
+      speech_recognition_session_id_(
+          SpeechRecognitionManager::kSessionIDInvalid) {
   registrar_->Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                   content::Source<Profile>(profile_));
 }
 
 SpeechInputExtensionManager::~SpeechInputExtensionManager() {
 }
 
 SpeechInputExtensionManager* SpeechInputExtensionManager::GetForProfile(
     Profile* profile) {
   SpeechInputExtensionManagerWrapper* wrapper =
@@ skipping 15 matching lines @@
         content::Details<UnloadedExtensionInfo>(details)->extension->id());
   } else {
     NOTREACHED();
   }
 }
 
 void SpeechInputExtensionManager::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Profile shutting down.";
 
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&SpeechRecognitionManager::AbortAllSessionsForListener,
+                 base::Unretained(SpeechRecognitionManager::GetInstance()),
+                 base::Unretained(this)));
+
   base::AutoLock auto_lock(state_lock_);
   DCHECK(state_ != kShutdown);
   if (state_ != kIdle) {
-    DCHECK(notification_.get());
-    notification_->Hide();
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         base::Bind(&SpeechInputExtensionManager::ForceStopOnIOThread, this));
   }
   state_ = kShutdown;
   VLOG(1) << "Entering the shutdown sink state.";
   registrar_.reset();
   profile_ = NULL;
 }
 
 void SpeechInputExtensionManager::ExtensionUnloaded(
@@ skipping 26 matching lines @@
 void SpeechInputExtensionManager::ResetToIdleState() {
   VLOG(1) << "State changed to idle. Deassociating any extensions.";
   state_ = kIdle;
   extension_id_in_use_.clear();
 }
 
 void SpeechInputExtensionManager::OnRecognitionResult(
     int session_id,
     const content::SpeechRecognitionResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(session_id, kSpeechInputSessionId);
+  DCHECK_EQ(session_id, speech_recognition_session_id_);
 
   // 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 22 matching lines @@
         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 session_id) {
-  DCHECK_EQ(session_id, kSpeechInputSessionId);
+  DCHECK_EQ(session_id, speech_recognition_session_id_);
 }
 
 void SpeechInputExtensionManager::OnAudioStart(int session_id) {
   VLOG(1) << "OnAudioStart";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(session_id, kSpeechInputSessionId);
+  DCHECK_EQ(session_id, speech_recognition_session_id_);
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::DidStartReceivingAudioOnUIThread,
       this));
 }
 
 void SpeechInputExtensionManager::OnAudioEnd(int session_id) {
-  DCHECK_EQ(session_id, kSpeechInputSessionId);
 }
 
 void SpeechInputExtensionManager::OnRecognitionEnd(int session_id) {
-  DCHECK_EQ(session_id, kSpeechInputSessionId);
+  // In the very exceptional case in which we requested a new recognition before
+  // the previous one ended, don't clobber the speech_recognition_session_id_.
+  if (speech_recognition_session_id_ == session_id) {
+    is_recognition_in_progress_ = false;
+    speech_recognition_session_id_ =
+        SpeechRecognitionManager::kSessionIDInvalid;
+  }
 }
 
 void SpeechInputExtensionManager::DidStartReceivingAudioOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
   DCHECK_EQ(state_, kStarting);
   VLOG(1) << "State changed to recording";
   state_ = kRecording;
 
-  const Extension* extension = profile_->GetExtensionService()->
-      GetExtensionById(extension_id_in_use_, true);
-  DCHECK(extension);
-
-  bool show_notification = !profile_->GetPrefs()->GetBoolean(
-      prefs::kSpeechInputTrayNotificationShown);
-
-  if (!notification_.get())
-    notification_ = new SpeechRecognitionTrayIconController();
-  notification_->Show(UTF8ToUTF16(extension->name()), show_notification);
-
-  if (show_notification) {
-    profile_->GetPrefs()->SetBoolean(
-        prefs::kSpeechInputTrayNotificationShown, true);
-  }
+  DCHECK(profile_);
+  profile_->GetPrefs()->SetBoolean(
+      prefs::kSpeechInputTrayNotificationShown, true);

[hans, 2012/05/15 13:35:17]

this looks like a simplification of the old code..
but I can't figure out what the old code actually did?

it first does GetBoolean(prefs::kSpeechInputTrayNotificationShown), and then  if
that's true, it later calls SetBoolean(prefs::kSpeechInputTrayNotificationShown,
true) ???

[Primiano Tucci (use gerrit), 2012/05/16 10:16:00]

The previous code was doing 3 things:
 (a) checking if a security balloon is needed (only the first time ever for an
extension)
 (b) extracting the extension name for the security balloon
 (c) setting the flag, which avoids showing the balloon in future for the
profile.

(a) and (b) have been moved to SpeechInputExtensionManager::Start. With this CL
the extension name and the need of the security balloon are put into the
SRSessionContext upon Start.

The only thing left here is (c).

 
   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 session_id, const content::SpeechRecognitionError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(session_id, kSpeechInputSessionId);
 
   // Simply return in case of an ERROR_ABORTED, since it is not contemplated
   // in the speech input extensions architecture.
   if (error.code == content::SPEECH_RECOGNITION_ERROR_ABORTED)
       return;
 
+  DCHECK_EQ(session_id, speech_recognition_session_id_);
   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 38 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 session_id) {
-  DCHECK_EQ(session_id, kSpeechInputSessionId);
+  DCHECK_EQ(session_id, speech_recognition_session_id_);
 }
 
 void SpeechInputExtensionManager::OnSoundStart(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK_EQ(session_id, kSpeechInputSessionId);
+  DCHECK_EQ(session_id, speech_recognition_session_id_);
   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 session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  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 22 matching lines @@
 void SpeechInputExtensionManager::DispatchError(
     const std::string& error, bool dispatch_event) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string extension_id;
   {
     base::AutoLock auto_lock(state_lock_);
     if (state_ == kShutdown)
       return;
 
-    if (state_ == kRecording) {
-      DCHECK(notification_.get());
-      notification_->Hide();
-    }
-
     extension_id = extension_id_in_use_;
     ResetToIdleState();
 
     // Will set the error property in the ongoing extension function calls.
     ExtensionError details(extension_id, error);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_FAILED,
         content::Source<Profile>(profile_),
         content::Details<ExtensionError>(&details));
   }
@@ skipping 35 matching lines @@
 
     case kRecording:
     case kStopping:
       *error = kErrorInvalidOperation;
       return false;
 
     default:
       NOTREACHED();
   }
 
+  const Extension* extension = profile_->GetExtensionService()->
+      GetExtensionById(extension_id, true);
+  DCHECK(extension);
+  const string16& extension_name = UTF8ToUTF16(extension->name());
+
   extension_id_in_use_ = extension_id;
   VLOG(1) << "State changed to starting";
   state_ = kStarting;
 
+  // Checks if the security notification balloon has been already shown (only
+  // once for a profile). It is reset on DidStartReceivingAudioOnUIThread.
+  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
+      profile_->GetRequestContext();
+  const bool show_notification = !profile_->GetPrefs()->GetBoolean(
+       prefs::kSpeechInputTrayNotificationShown);
+
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::StartOnIOThread, this,
-                 profile_->GetRequestContext(), language, grammar,
-                 filter_profanities));
+                 url_request_context_getter, extension_name, language, grammar,
+                 filter_profanities, show_notification));
   return true;
 }
 
 void SpeechInputExtensionManager::StartOnIOThread(
-    net::URLRequestContextGetter* context_getter,
+    scoped_refptr<net::URLRequestContextGetter> context_getter,
+    const string16& extension_name,
     const std::string& language,
     const std::string& grammar,
-    bool filter_profanities) {
+    bool filter_profanities,
+    bool show_notification) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   VLOG(1) << "Requesting start (IO thread)";
 
   // Everything put inside the lock to ensure the validity of context_getter,
   // guaranteed while not in the shutdown state. Any ongoing or recognition
   // request will be requested to be aborted when entering the shutdown state.
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
   if (!GetSpeechInputExtensionInterface()->HasAudioInputDevices()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&SpeechInputExtensionManager::DispatchError, this,
                    std::string(kErrorNoRecordingDeviceFound), false));
     return;
   }
 
   if (GetSpeechInputExtensionInterface()->IsCapturingAudio()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&SpeechInputExtensionManager::DispatchError, this,
         std::string(kErrorRecordingDeviceInUse), false));
     return;
   }
 
-  GetSpeechInputExtensionInterface()->StartRecording(
-      this, context_getter, kSpeechInputSessionId, language, grammar,
-      filter_profanities);
+  GetSpeechInputExtensionInterface()->StartRecording(this,
+                                                     context_getter,
+                                                     extension_name,
+                                                     language,
+                                                     grammar,
+                                                     filter_profanities,
+                                                     show_notification);
 }
 
 bool SpeechInputExtensionManager::HasAudioInputDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return SpeechRecognitionManager::GetInstance()->HasAudioInputDevices();
 }
 
 bool SpeechInputExtensionManager::IsCapturingAudio() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return SpeechRecognitionManager::GetInstance()->IsCapturingAudio();
@@ skipping 22 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 session_id,
+    const string16& extension_name,
     const std::string& language,
     const std::string& grammar,
-    bool filter_profanities) {
+    bool filter_profanities,
+    bool show_notification) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(!recognizer_);
-  recognizer_ = content::SpeechRecognizer::Create(
-      listener, session_id, language, grammar, context_getter,
-      filter_profanities, "", "");
-  recognizer_->StartRecognition();
+
+  content::SpeechRecognitionSessionContext context;
+  context.use_bubble_on_element = false;
+  context.show_security_balloon = show_notification;
+  context.context_name = extension_name;
+
+  content::SpeechRecognitionSessionConfig config;
+  // config.is_one_shot = true; // TODO(primiano) Uncomment when CL2.0 lands.
+  config.language = language;
+  config.grammar = grammar;
+  config.initial_context = context;
+  config.url_request_context_getter = context_getter;
+  config.filter_profanities = filter_profanities;
+  config.event_listener = listener;
+
+  DCHECK(!is_recognition_in_progress_);
+  SpeechRecognitionManager& manager = *SpeechRecognitionManager::GetInstance();
+  speech_recognition_session_id_ =
+      manager.CreateSession(config);
+  DCHECK_NE(speech_recognition_session_id_,
+            SpeechRecognitionManager::kSessionIDInvalid);
+  is_recognition_in_progress_ = true;
+  manager.StartSession(speech_recognition_session_id_);
 }
 
 bool SpeechInputExtensionManager::HasValidRecognizer() {
-  return !!recognizer_;
+  if (!is_recognition_in_progress_)
+    return false;
+  return SpeechRecognitionManager::GetInstance()->IsCapturingAudio();
 }
 
 bool SpeechInputExtensionManager::Stop(const std::string& extension_id,
     std::string* error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   VLOG(1) << "Requesting stop (UI thread)";
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown ||
@@ skipping 40 matching lines @@
   GetSpeechInputExtensionInterface()->StopRecording(false);
 
   if (state_ == kShutdown)
     return;
 
   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_->AbortRecognition();
-    recognizer_.release();
-  }
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (!is_recognition_in_progress_)
+    return;
+  DCHECK_NE(speech_recognition_session_id_,
+            SpeechRecognitionManager::kSessionIDInvalid);
+  SpeechRecognitionManager::GetInstance()->AbortSession(
+      speech_recognition_session_id_);
 }
 
 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::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);
-}
+                                                      float volume,
+                                                      float noise_volume) {}