Speech JavaScript API: Use the MediaStreamManager to ask for user permission.

content/browser/speech/speech_recognition_manager_impl.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 "content/browser/speech/speech_recognition_manager_impl.h"
 
 #include "base/bind.h"
 #include "content/browser/browser_main_loop.h"
+#include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/speech/google_one_shot_remote_engine.h"
 #include "content/browser/speech/google_streaming_remote_engine.h"
 #include "content/browser/speech/speech_recognition_engine.h"
 #include "content/browser/speech/speech_recognizer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 #include "content/public/browser/speech_recognition_manager_delegate.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 "media/audio/audio_manager.h"
 
 using base::Callback;
 using content::BrowserMainLoop;
 using content::BrowserThread;
-using content::SpeechRecognitionError;
 using content::SpeechRecognitionEventListener;
 using content::SpeechRecognitionManager;
 using content::SpeechRecognitionResult;
 using content::SpeechRecognitionSessionContext;
 using content::SpeechRecognitionSessionConfig;
 
 namespace content {
 SpeechRecognitionManager* SpeechRecognitionManager::GetInstance() {
   return speech::SpeechRecognitionManagerImpl::GetInstance();
 }
 }  // namespace content
 
 namespace {
 speech::SpeechRecognitionManagerImpl* g_speech_recognition_manager_impl;
 
 void ShowAudioInputSettingsOnFileThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   media::AudioManager* audio_manager = BrowserMainLoop::GetAudioManager();
   DCHECK(audio_manager->CanShowAudioInputSettings());
   if (audio_manager->CanShowAudioInputSettings())
     audio_manager->ShowAudioInputSettings();
 }
 }  // namespace
 
 namespace speech {
 
+class SpeechRecognitionManagerImpl::PermissionRequest
+    : public media_stream::MediaStreamRequester {
+ public:
+  PermissionRequest(media_stream::MediaStreamManager* media_stream_manager,
+                    int session_id,
+                    const base::Callback<void(bool is_allowed)>& callback)
+      : media_stream_manager_(media_stream_manager),
+        session_id_(session_id),
+        callback_(callback),
+        started_(false) {
+  }
+
+  virtual ~PermissionRequest() {
+    if (started_)
+      Abort();
+  }
+
+  void Start(int render_process_id, int render_view_id, const GURL& origin) {
+    started_ = true;
+    media_stream_manager_->GenerateStream(
+        this,
+        render_process_id,
+        render_view_id,
+        media_stream::StreamOptions(/*audio=*/true, /*video=*/false),
+        origin,
+        &label_);
+  }
+
+  void Abort() {
+    started_ = false;
+    media_stream_manager_->CancelGenerateStream(label_);
+  }
+
+  int Session() const { return session_id_; }
+
+  // MediaStreamRequester methods.
+  virtual void StreamGenerated(
+      const std::string& label,
+      const media_stream::StreamDeviceInfoArray& audio_devices,
+      const media_stream::StreamDeviceInfoArray& video_devices) OVERRIDE {
+    // TODO(hans): One day it would be nice to actually use the generated stream
+    // but right now we only use it to request permission, and then we dump it.
+    started_ = false;
+    BrowserThread::PostTask(

[wjia(left Chromium), 2012/09/12 22:58:25]

StreamGenerated is called on IO thread. Do you need this PostTask?

Do you have plan to use other MediaStreamManager besides
BrowserMainLoop::GetMediaStreamManager()?The |media_stream_manager_| has to be
valid till this task is executed.

+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&media_stream::MediaStreamManager::StopGeneratedStream,
+                   base::Unretained(media_stream_manager_),
+                   label));
+    callback_.Run(true);
+  }
+
+  virtual void StreamGenerationFailed(const std::string& label) OVERRIDE {
+    started_ = false;
+    callback_.Run(false);
+  }
+
+  // The callbacks below are ignored.
+  virtual void AudioDeviceFailed(const std::string& label,
+                                 int index) OVERRIDE {}
+  virtual void VideoDeviceFailed(const std::string& label,
+                                 int index) OVERRIDE {}
+  virtual void DevicesEnumerated(
+      const std::string& label,
+      const media_stream::StreamDeviceInfoArray& devices) OVERRIDE {}
+  virtual void DeviceOpened(
+      const std::string& label,
+      const media_stream::StreamDeviceInfo& device_info) OVERRIDE {}
+
+ private:
+  media_stream::MediaStreamManager* media_stream_manager_;
+  int session_id_;
+  base::Callback<void(bool is_allowed)> callback_;
+  std::string label_;
+  bool started_;
+};
+
 SpeechRecognitionManagerImpl* SpeechRecognitionManagerImpl::GetInstance() {
   return g_speech_recognition_manager_impl;
 }
 
 SpeechRecognitionManagerImpl::SpeechRecognitionManagerImpl()
-    : session_id_capturing_audio_(kSessionIDInvalid),
+    : primary_session_id_(kSessionIDInvalid),
       last_session_id_(kSessionIDInvalid),
       is_dispatching_event_(false),
       delegate_(content::GetContentClient()->browser()->
                     GetSpeechRecognitionManagerDelegate()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(!g_speech_recognition_manager_impl);
   g_speech_recognition_manager_impl = this;
 }
 
 SpeechRecognitionManagerImpl::~SpeechRecognitionManagerImpl() {
@@ skipping 48 matching lines @@
                                             google_remote_engine);
   return session_id;
 }
 
 void SpeechRecognitionManagerImpl::StartSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   // If there is another active session, abort that.
-  if (session_id_capturing_audio_ != kSessionIDInvalid &&
-      session_id_capturing_audio_ != session_id) {
-    AbortSession(session_id_capturing_audio_);
+  if (primary_session_id_ != kSessionIDInvalid &&
+      primary_session_id_ != session_id) {
+    AbortSession(primary_session_id_);
   }
 
-  if (delegate_.get())
+  primary_session_id_ = session_id;
+
+  if (delegate_.get()) {
     delegate_->CheckRecognitionIsAllowed(
         session_id,
         base::Bind(&SpeechRecognitionManagerImpl::RecognitionAllowedCallback,
-                   weak_factory_.GetWeakPtr()));
+                   weak_factory_.GetWeakPtr(),
+                   session_id));
+  }
 }
 
 void SpeechRecognitionManagerImpl::RecognitionAllowedCallback(int session_id,
+                                                              bool ask_user,
                                                               bool is_allowed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(SessionExists(session_id));
+  if (!SessionExists(session_id))
+    return;
+
+  if (ask_user) {
+    media_stream::MediaStreamManager* media_stream_manager =
+        BrowserMainLoop::GetMediaStreamManager();
+
+    const SpeechRecognitionSessionContext& context =
+        GetSessionContext(session_id);
+
+    permission_request_.reset(new PermissionRequest(
+        media_stream_manager,
+        session_id,
+        base::Bind(&SpeechRecognitionManagerImpl::RecognitionAllowedCallback,
+                   weak_factory_.GetWeakPtr(),
+                   session_id,
+                   false)));
+
+    permission_request_->Start(context.render_process_id,
+                               context.render_view_id,
+                               GURL(context.context_name));
+
+    return;
+  }
+
+  permission_request_.reset();
+
   if (is_allowed) {
     MessageLoop::current()->PostTask(FROM_HERE,
         base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                    weak_factory_.GetWeakPtr(), session_id, EVENT_START));
   } else {
-    sessions_.erase(session_id);
+    OnRecognitionError(session_id, content::SpeechRecognitionError(
+        content::SPEECH_RECOGNITION_ERROR_NOT_ALLOWED));
+    MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
+                   weak_factory_.GetWeakPtr(), session_id, EVENT_ABORT));
   }
 }
 
 void SpeechRecognitionManagerImpl::AbortSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
+  if (permission_request_.get() &&
+      permission_request_->Session() == session_id) {
+    DCHECK(permission_request_.get());
+    permission_request_->Abort();
+  }
+
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                  weak_factory_.GetWeakPtr(), session_id, EVENT_ABORT));
 }
 
 void SpeechRecognitionManagerImpl::StopAudioCaptureForSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
+  if (permission_request_.get() &&
+      permission_request_->Session() == session_id) {
+    DCHECK(permission_request_.get());
+    permission_request_->Abort();
+  }
+
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                  weak_factory_.GetWeakPtr(), session_id, EVENT_STOP_CAPTURE));
 }
 
 // Here begins the SpeechRecognitionEventListener interface implementation,
 // which will simply relay the events to the proper listener registered for the
 // particular session (most likely InputTagSpeechDispatcherHost) and to the
 // catch-all listener provided by the delegate (if any).
 
 void SpeechRecognitionManagerImpl::OnRecognitionStart(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
-  DCHECK_EQ(session_id_capturing_audio_, session_id);
+  DCHECK_EQ(primary_session_id_, session_id);
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnRecognitionStart(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnRecognitionStart(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnAudioStart(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
-  DCHECK_EQ(session_id_capturing_audio_, session_id);
+  DCHECK_EQ(primary_session_id_, session_id);
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnAudioStart(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnAudioStart(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnEnvironmentEstimationComplete(
     int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
-  DCHECK_EQ(session_id_capturing_audio_, session_id);
+  DCHECK_EQ(primary_session_id_, session_id);
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnEnvironmentEstimationComplete(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnEnvironmentEstimationComplete(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnSoundStart(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
-  DCHECK_EQ(session_id_capturing_audio_, session_id);
+  DCHECK_EQ(primary_session_id_, session_id);
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnSoundStart(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnSoundStart(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnSoundEnd(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
@@ skipping 159 matching lines @@
   // completed the transition from CAPTURING_AUDIO to WAITING_FOR_RESULT, thus
   // we perceive the AUDIO_ENDED event in WAITING_FOR_RESULT).
   // This makes the code below a bit tricky but avoids a lot of code for
   // tracking and reconstructing asynchronously the state of the recognizer.
   switch (session_state) {
     case SESSION_STATE_IDLE:
       switch (event) {
         case EVENT_START:
           return SessionStart(session);
         case EVENT_ABORT:
+          return SessionAbort(session);
         case EVENT_RECOGNITION_ENDED:
           return SessionDelete(session);
         case EVENT_STOP_CAPTURE:
+          return SessionStopAudioCapture(session);
         case EVENT_AUDIO_ENDED:
           return;
       }
       break;
     case SESSION_STATE_CAPTURING_AUDIO:
       switch (event) {
         case EVENT_STOP_CAPTURE:
           return SessionStopAudioCapture(session);
         case EVENT_ABORT:
           return SessionAbort(session);
@@ skipping 29 matching lines @@
   if (session.recognizer->IsCapturingAudio())
     return SESSION_STATE_CAPTURING_AUDIO;
   return SESSION_STATE_WAITING_FOR_RESULT;
 }
 
 // ----------- Contract for all the FSM evolution functions below -------------
 //  - Are guaranteed to be executed in the IO thread;
 //  - Are guaranteed to be not reentrant (themselves and each other);
 
 void SpeechRecognitionManagerImpl::SessionStart(const Session& session) {
-  session_id_capturing_audio_ = session.id;
+  DCHECK_EQ(primary_session_id_, session.id);
   session.recognizer->StartRecognition();
 }
 
 void SpeechRecognitionManagerImpl::SessionAbort(const Session& session) {
-  if (session_id_capturing_audio_ == session.id)
-    session_id_capturing_audio_ = kSessionIDInvalid;
-  DCHECK(session.recognizer.get() && session.recognizer->IsActive());
+  if (primary_session_id_ == session.id)
+    primary_session_id_ = kSessionIDInvalid;
+  DCHECK(session.recognizer.get());
   session.recognizer->AbortRecognition();
 }
 
 void SpeechRecognitionManagerImpl::SessionStopAudioCapture(
     const Session& session) {
-  DCHECK(session.recognizer.get() && session.recognizer->IsCapturingAudio());
+  DCHECK(session.recognizer.get());
   session.recognizer->StopAudioCapture();
 }
 
 void SpeechRecognitionManagerImpl::ResetCapturingSessionId(
     const Session& session) {
-  DCHECK_EQ(session_id_capturing_audio_, session.id);
-  session_id_capturing_audio_ = kSessionIDInvalid;
+  DCHECK_EQ(primary_session_id_, session.id);
+  primary_session_id_ = kSessionIDInvalid;
 }
 
 void SpeechRecognitionManagerImpl::SessionDelete(const Session& session) {
   DCHECK(session.recognizer == NULL || !session.recognizer->IsActive());
-  if (session_id_capturing_audio_ == session.id)
-    session_id_capturing_audio_ = kSessionIDInvalid;
+  if (primary_session_id_ == session.id)
+    primary_session_id_ = kSessionIDInvalid;
   sessions_.erase(session.id);
 }
 
 void SpeechRecognitionManagerImpl::NotFeasible(const Session& session,
                                                FSMEvent event) {
   NOTREACHED() << "Unfeasible event " << event
                << " in state " << GetSessionState(session.id)
                << " for session " << session.id;
 }
 
@@ skipping 54 matching lines @@
 
 SpeechRecognitionManagerImpl::Session::Session()
   : id(kSessionIDInvalid),
     listener_is_active(true) {
 }
 
 SpeechRecognitionManagerImpl::Session::~Session() {
 }
 
 }  // namespace speech