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 16 matching lines @@
             extension->id());
   } else {
     NOTREACHED();
   }
 }
 
 void SpeechInputExtensionManager::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Profile shutting down.";
 
+  // Note: Unretained(this) is safe, also if we are freed in the meanwhile.
+  // It is used by the SR manager just for comparing the raw pointer and remove
+  // the associated sessions.
+  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 extensions::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);
 
   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;
   bool report_to_event = true;
 
   switch (error.code) {
     case content::SPEECH_RECOGNITION_ERROR_NONE:
       break;
 
+    case content::SPEECH_RECOGNITION_ERROR_ABORTED:
+      // ERROR_ABORTED is received whenever AbortSession is called on the
+      // manager. However, we want propagate the error only if it is triggered
+      // by an external cause (another recognition started, aborting us), thus
+      // only if it occurs while we are capturing audio.
+      if (state_ == kRecording)
+        event_error_code = kErrorCaptureError;
+      break;
+
     case content::SPEECH_RECOGNITION_ERROR_AUDIO:
       if (state_ == kStarting) {
         event_error_code = kErrorUnableToStart;
         report_to_event = false;
       } else {
         event_error_code = kErrorCaptureError;
       }
       break;
 
     case content::SPEECH_RECOGNITION_ERROR_NETWORK:
@@ skipping 22 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 extensions::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;
 
+  // TODO(primiano) These two checks below could be avoided, since they are
+  // already handled in the speech recognition classes. However, since the
+  // speech input extensions tests are bypassing the manager, we need them to
+  // pass the tests. A complete unit test which puts all the pieces together,
+  // mocking just the endpoints (the audio input controller and the URL fetcher)
+  // should be written.
   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();
 }
 
 void SpeechInputExtensionManager::IsRecording(
     const IsRecordingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::IsRecordingOnIOThread,
                  this, callback));
 }
 
 void SpeechInputExtensionManager::IsRecordingOnIOThread(
     const IsRecordingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   bool result = GetSpeechInputExtensionInterface()->IsCapturingAudio();
+
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::IsRecordingOnUIThread,
                  this, callback, result));
 }
 
 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.requested_by_page_element = false;
+  context.is_first_request_for_context = 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.grammars.push_back(content::SpeechRecognitionGrammar(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) {}