Add a noise indicator to the speech bubble volume indicator.

chrome/browser/speech/speech_input_manager.cc

 // Copyright (c) 2011 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_input_manager.h"
 
 #include <map>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/browser_thread.h"

[hans, 2011/03/01 17:25:25]

nit: alpha include order

 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/speech/speech_input_bubble_controller.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/speech/speech_recognizer.h"
 #include "grit/generated_resources.h"
@@ skipping 87 matching lines @@
 
   // SpeechRecognizer::Delegate methods.
   virtual void SetRecognitionResult(int caller_id,
                                     bool error,
                                     const SpeechInputResultArray& result);
   virtual void DidCompleteRecording(int caller_id);
   virtual void DidCompleteRecognition(int caller_id);
   virtual void OnRecognizerError(int caller_id,
                                  SpeechRecognizer::ErrorCode error);
   virtual void DidCompleteEnvironmentEstimation(int caller_id);
-  virtual void SetInputVolume(int caller_id, float volume);
+  virtual void SetInputVolume(int caller_id, float volume, float noise_volume);
 
   // SpeechInputBubbleController::Delegate methods.
   virtual void InfoBubbleButtonClicked(int caller_id,
                                        SpeechInputBubble::Button button);
   virtual void InfoBubbleFocusChanged(int caller_id);
 
  private:
   struct SpeechInputRequest {
     SpeechInputManagerDelegate* delegate;
     scoped_refptr<SpeechRecognizer> recognizer;
@@ skipping 42 matching lines @@
     // Official Chrome builds have speech input enabled by default only in the
     // dev channel.
     std::string channel = platform_util::GetVersionStringModifier();
     enabled = (channel == "dev");
 #endif
   }
 
   return enabled;
 }
 
+void SpeechInputManager::ShowAudioInputSettings() {
+  // Since AudioManager::ShowAudioInputSettings can potentially launch external
+  // processes, do that in the PROCESS_LAUNCHER thread to not block the calling
+  // threads.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER)) {
+    BrowserThread::PostTask(
+        BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
+        NewRunnableFunction(&SpeechInputManager::ShowAudioInputSettings));
+    return;
+  }
+
+  DCHECK(AudioManager::GetAudioManager()->CanShowAudioInputSettings());

[bulach, 2011/03/01 17:39:04]

how expensive is this call?
if it's cheap, you may want to avoid round tripping the threads and checking it
before PostTask..

+  if (AudioManager::GetAudioManager()->CanShowAudioInputSettings())
+    AudioManager::GetAudioManager()->ShowAudioInputSettings();
+}
+
 SpeechInputManagerImpl::SpeechInputManagerImpl()
     : recording_caller_id_(0),
       bubble_controller_(new SpeechInputBubbleController(
           ALLOW_THIS_IN_INITIALIZER_LIST(this))) {
 }
 
 SpeechInputManagerImpl::~SpeechInputManagerImpl() {
   while (requests_.begin() != requests_.end())
     CancelRecognition(requests_.begin()->first);
 }
@@ skipping 137 matching lines @@
 
 void SpeechInputManagerImpl::DidCompleteEnvironmentEstimation(int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
   DCHECK(recording_caller_id_ == caller_id);
 
   // Speech recognizer has gathered enough background audio so we can ask the
   // user to start speaking.
   bubble_controller_->SetBubbleRecordingMode(caller_id);
 }
 
-void SpeechInputManagerImpl::SetInputVolume(int caller_id, float volume) {
+void SpeechInputManagerImpl::SetInputVolume(int caller_id, float volume,
+                                            float noise_volume) {
   DCHECK(HasPendingRequest(caller_id));
   DCHECK_EQ(recording_caller_id_, caller_id);
 
-  bubble_controller_->SetBubbleInputVolume(caller_id, volume);
+  bubble_controller_->SetBubbleInputVolume(caller_id, volume, noise_volume);
 }
 
 void SpeechInputManagerImpl::CancelRecognitionAndInformDelegate(int caller_id) {
   SpeechInputManagerDelegate* cur_delegate = GetDelegate(caller_id);
   CancelRecognition(caller_id);
   cur_delegate->DidCompleteRecording(caller_id);
   cur_delegate->DidCompleteRecognition(caller_id);
 }
 
 void SpeechInputManagerImpl::InfoBubbleButtonClicked(
@@ skipping 22 matching lines @@
     // to the user, abort it since user has switched focus. Otherwise
     // recognition has started and keep that going so user can start speaking to
     // another element while this gets the results in parallel.
     if (recording_caller_id_ == caller_id || !requests_[caller_id].is_active) {
       CancelRecognitionAndInformDelegate(caller_id);
     }
   }
 }
 
 }  // namespace speech_input