Speech refactoring: Reimplemented SpeechRecognitionManagerImpl as a FSM. (CL1.7)

chrome/browser/speech/chrome_speech_recognition_manager_delegate.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/chrome_speech_recognition_manager_delegate.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/speech_recognition_manager.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
+#include "content/public/browser/speech_recognition_session_context.h"

[jam, 2012/04/24 15:56:32]

nit: order

[Primiano Tucci (use gerrit), 2012/04/25 11:30:03]

Ops, sorry.

 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "chrome/installer/util/wmi.h"
 #endif
 
+using base::WaitableEvent;
 using content::BrowserThread;
 using content::SpeechRecognitionManager;
+using content::SpeechRecognitionSessionContext;
 
 namespace speech {
 
 // Asynchronously fetches the PC and audio hardware/driver info if
 // the user has opted into UMA. This information is sent with speech input
 // requests to the server for identifying and improving quality issues with
 // specific device configurations.
 class ChromeSpeechRecognitionManagerDelegate::OptionalRequestInfo
     : public base::RefCountedThreadSafe<OptionalRequestInfo> {
  public:
@@ skipping 56 matching lines @@
 ChromeSpeechRecognitionManagerDelegate::ChromeSpeechRecognitionManagerDelegate()
     : bubble_controller_(new SpeechRecognitionBubbleController(
           ALLOW_THIS_IN_INITIALIZER_LIST(this))) {
 }
 
 ChromeSpeechRecognitionManagerDelegate::
     ~ChromeSpeechRecognitionManagerDelegate() {
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowRecognitionRequested(
-    int session_id,
-    int render_process_id,
-    int render_view_id,
-    const gfx::Rect& element_rect) {
-  bubble_controller_->CreateBubble(session_id, render_process_id,
-                                   render_view_id, element_rect);
+    int session_id) {
+  const SpeechRecognitionSessionContext& context =
+      SpeechRecognitionManager::GetInstance()->GetSessionContext(session_id);
+  bubble_controller_->CreateBubble(session_id,
+                                   context.render_process_id,
+                                   context.render_view_id,
+                                   context.element_rect);
 }
 
-void ChromeSpeechRecognitionManagerDelegate::GetRequestInfo(
+void ChromeSpeechRecognitionManagerDelegate::GetDiagnosticInformation(
     bool* can_report_metrics,
-    std::string* request_info) {
+    std::string* hardware_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!optional_request_info_.get()) {
     optional_request_info_ = new OptionalRequestInfo();
     // Since hardware info is optional with speech input requests, we start an
     // asynchronous fetch here and move on with recording audio. This first
     // speech input request would send an empty string for hardware info and
     // subsequent requests may have the hardware info available if the fetch
     // completed before them. This way we don't end up stalling the user with
     // a long wait and disk seeks when they click on a UI element and start
     // speaking.
     optional_request_info_->Refresh();
   }
   *can_report_metrics = optional_request_info_->can_report_metrics();
-  *request_info = optional_request_info_->value();
+  *hardware_info = optional_request_info_->value();
+}
+
+bool ChromeSpeechRecognitionManagerDelegate::IsRecognitionAllowed(
+    int session_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  const SpeechRecognitionSessionContext& context =
+      SpeechRecognitionManager::GetInstance()->GetSessionContext(session_id);
+  bool check_result = false;
+  WaitableEvent event(false /*manual_reset*/, false /*initially_signaled*/);

[jam, 2012/04/24 15:56:32]

we most definitely do not block one thread on another, this is a recipe for
deadlock and jank. you'll need to find another way of doing this asynchronously.
ideally all the SpeechManagerDelegate methods are called on the same thread (UI)
as this keeps the public api simple.

see the first parts of
http://dev.chromium.org/developers/design-documents/threading

[Primiano Tucci (use gerrit), 2012/04/25 11:30:03]

Hmm, right. The problem is that I am doing a very trivial check
(render_view_host->GetDelegate()->GetRenderViewType() ==
content::VIEW_TYPE_WEB_CONTENTS) that, unfortunately, needs to be performed in
the UI thread. I modified the implementation making that check asynchronous.
However any different (and hopefully simpler) approach is more than welcome.

+
+  BrowserThread::PostTask(
+    BrowserThread::UI, FROM_HERE,
+        base::Bind(&CheckRenderViewType,
+                   context.render_process_id,
+                   context.render_view_id,
+                   base::Unretained(&check_result),
+                   base::Unretained(&event)));
+  event.Wait();
+  return check_result;
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowWarmUp(int session_id) {
   bubble_controller_->SetBubbleWarmUpMode(session_id);
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowRecognizing(int session_id) {
   bubble_controller_->SetBubbleRecognizingMode(session_id);
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowRecording(int session_id) {
   bubble_controller_->SetBubbleRecordingMode(session_id);
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowInputVolume(
     int session_id, float volume, float noise_volume) {
   bubble_controller_->SetBubbleInputVolume(session_id, volume, noise_volume);
 }
 
-void ChromeSpeechRecognitionManagerDelegate::ShowMicError(int session_id,
-                                                          MicError error) {
-  switch (error) {
-    case MIC_ERROR_NO_DEVICE_AVAILABLE:
-      bubble_controller_->SetBubbleMessage(
-          session_id, l10n_util::GetStringUTF16(IDS_SPEECH_INPUT_NO_MIC));
+void ChromeSpeechRecognitionManagerDelegate::ShowError(
+    int session_id, const content::SpeechRecognitionError& error) {
+  int error_message_id = 0;
+  switch (error.code) {
+    case content::SPEECH_RECOGNITION_ERROR_AUDIO:
+      switch (error.details) {
+        case content::SPEECH_AUDIO_ERROR_DETAILS_NO_MIC:
+          error_message_id = IDS_SPEECH_INPUT_NO_MIC;
+          break;
+        case content::SPEECH_AUDIO_ERROR_DETAILS_IN_USE:
+          error_message_id = IDS_SPEECH_INPUT_MIC_IN_USE;
+          break;
+        default:
+          error_message_id = IDS_SPEECH_INPUT_MIC_ERROR;
+          break;
+      }
       break;
-
-    case MIC_ERROR_DEVICE_IN_USE:
-      bubble_controller_->SetBubbleMessage(
-          session_id, l10n_util::GetStringUTF16(IDS_SPEECH_INPUT_MIC_IN_USE));
+    case content::SPEECH_RECOGNITION_ERROR_NO_SPEECH:
+      error_message_id = IDS_SPEECH_INPUT_NO_SPEECH;
       break;
-
+    case content::SPEECH_RECOGNITION_ERROR_NO_MATCH:
+      error_message_id = IDS_SPEECH_INPUT_NO_RESULTS;
+      break;
+    case content::SPEECH_RECOGNITION_ERROR_NETWORK:
+      error_message_id = IDS_SPEECH_INPUT_NET_ERROR;
+      break;
     default:
-      NOTREACHED();
+      NOTREACHED() << "unknown error " << error.code;
+      return;
   }
-}
-
-void ChromeSpeechRecognitionManagerDelegate::ShowRecognizerError(
-    int session_id, content::SpeechRecognitionErrorCode error) {
-  struct ErrorMessageMapEntry {
-    content::SpeechRecognitionErrorCode error;
-    int message_id;
-  };
-  ErrorMessageMapEntry error_message_map[] = {
-    {
-      content::SPEECH_RECOGNITION_ERROR_AUDIO, IDS_SPEECH_INPUT_MIC_ERROR
-    }, {
-      content::SPEECH_RECOGNITION_ERROR_NO_SPEECH, IDS_SPEECH_INPUT_NO_SPEECH
-    }, {
-      content::SPEECH_RECOGNITION_ERROR_NO_MATCH, IDS_SPEECH_INPUT_NO_RESULTS
-    }, {
-      content::SPEECH_RECOGNITION_ERROR_NETWORK, IDS_SPEECH_INPUT_NET_ERROR
-    }
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(error_message_map); ++i) {
-    if (error_message_map[i].error == error) {
-      bubble_controller_->SetBubbleMessage(
-          session_id,
-          l10n_util::GetStringUTF16(error_message_map[i].message_id));
-      return;
-    }
-  }
-
-  NOTREACHED() << "unknown error " << error;
+  bubble_controller_->SetBubbleMessage(
+      session_id, l10n_util::GetStringUTF16(error_message_id));
 }
 
 void ChromeSpeechRecognitionManagerDelegate::DoClose(int session_id) {
   bubble_controller_->CloseBubble(session_id);
 }
 
 void ChromeSpeechRecognitionManagerDelegate::InfoBubbleButtonClicked(
     int session_id, SpeechRecognitionBubble::Button button) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (button == SpeechRecognitionBubble::BUTTON_CANCEL) {
-    SpeechRecognitionManager::GetInstance()->CancelRecognitionForRequest(
-        session_id);
+    SpeechRecognitionManager::GetInstance()->AbortSession(session_id);
   } else if (button == SpeechRecognitionBubble::BUTTON_TRY_AGAIN) {
-    SpeechRecognitionManager::GetInstance()->StartRecognitionForRequest(
-        session_id);
+    SpeechRecognitionManager::GetInstance()->StartSession(session_id);
   }
 }
 
 void ChromeSpeechRecognitionManagerDelegate::InfoBubbleFocusChanged(
     int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  SpeechRecognitionManager::GetInstance()->FocusLostForRequest(session_id);
+  SpeechRecognitionManager::GetInstance()->SendSessionToBackground(session_id);
+}
+
+void ChromeSpeechRecognitionManagerDelegate::CheckRenderViewType(
+    int render_process_id,
+    int render_view_id,
+    bool* result,
+    WaitableEvent* event) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const content::RenderViewHost* render_view_host =
+      content::RenderViewHost::FromID(render_process_id, render_view_id);
+  // For host delegates other than VIEW_TYPE_WEB_CONTENTS we can't reliably show
+  // a popup, including the speech input bubble. In these cases for privacy
+  // reasons we don't want to start recording if the user can't be properly
+  // notified. An example of this is trying to show the speech input bubble
+  // within an extension popup: http://crbug.com/92083. In these situations the
+  // speech input extension API should be used instead.
+  *result = (render_view_host != NULL &&
+             render_view_host->GetDelegate() != NULL &&
+             render_view_host->GetDelegate()->GetRenderViewType() ==
+                 content::VIEW_TYPE_WEB_CONTENTS);
+  event->Signal();
 }
 
 }  // namespace speech