Add a noise indicator to the speech bubble volume indicator.

chrome/browser/speech/speech_input_bubble_controller.cc

 // Copyright (c) 2010 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_bubble_controller.h"
 
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/notification_registrar.h"
@@ skipping 34 matching lines @@
                                                         element_rect);
   if (!bubble)  // could be null if tab or display rect were invalid.
     return;
 
   bubbles_[caller_id] = bubble;
 
   UpdateTabContentsSubscription(caller_id, BUBBLE_ADDED);
 }
 
 void SpeechInputBubbleController::CloseBubble(int caller_id) {
-  ProcessRequestInUiThread(caller_id, REQUEST_CLOSE, string16(), 0);
+  ProcessRequestInUiThread(caller_id, REQUEST_CLOSE, string16(), 0, 0);
 }
 
 void SpeechInputBubbleController::SetBubbleRecordingMode(int caller_id) {
   ProcessRequestInUiThread(caller_id, REQUEST_SET_RECORDING_MODE,
-                           string16(), 0);
+                           string16(), 0, 0);
 }
 
 void SpeechInputBubbleController::SetBubbleRecognizingMode(int caller_id) {
   ProcessRequestInUiThread(caller_id, REQUEST_SET_RECOGNIZING_MODE,
-                           string16(), 0);
+                           string16(), 0, 0);
 }
 
 void SpeechInputBubbleController::SetBubbleInputVolume(int caller_id,
-                                                       float volume) {
+                                                       float volume,
+                                                       float noise_volume) {
   ProcessRequestInUiThread(caller_id, REQUEST_SET_INPUT_VOLUME, string16(),
-                           volume);
+                           volume, noise_volume);
 }
 
 void SpeechInputBubbleController::SetBubbleMessage(int caller_id,
                                                    const string16& text) {
-  ProcessRequestInUiThread(caller_id, REQUEST_SET_MESSAGE, text, 0);
+  ProcessRequestInUiThread(caller_id, REQUEST_SET_MESSAGE, text, 0, 0);
 }
 
 void SpeechInputBubbleController::UpdateTabContentsSubscription(
     int caller_id, ManageSubscriptionAction action) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If there are any other bubbles existing for the same TabContents, we would
   // have subscribed to tab close notifications on their behalf and we need to
   // stay registered. So we don't change the subscription in such cases.
   TabContents* tab_contents = bubbles_[caller_id]->tab_contents();
@@ skipping 37 matching lines @@
       } else {
         ++iter;
       }
     }
   } else {
     NOTREACHED() << "Unknown notification";
   }
 }
 
 void SpeechInputBubbleController::ProcessRequestInUiThread(
-    int caller_id, RequestType type, const string16& text, float volume) {
+    int caller_id, RequestType type, const string16& text, float volume,
+    float noise_volume) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, NewRunnableMethod(
         this, &SpeechInputBubbleController::ProcessRequestInUiThread,
-        caller_id, type, text, volume));
+        caller_id, type, text, volume, noise_volume));
     return;
   }
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // The bubble may have been closed before we got a chance to process this
   // request. So check before proceeding.
   if (!bubbles_.count(caller_id))
     return;
 
   bool change_active_bubble = (type == REQUEST_SET_RECORDING_MODE ||
                                type == REQUEST_SET_MESSAGE);
   if (change_active_bubble) {
     if (current_bubble_caller_id_ && current_bubble_caller_id_ != caller_id)
       bubbles_[current_bubble_caller_id_]->Hide();
     current_bubble_caller_id_ = caller_id;
   }
 
   SpeechInputBubble* bubble = bubbles_[caller_id];
   switch (type) {
     case REQUEST_SET_RECORDING_MODE:
       bubble->SetRecordingMode();
       break;
     case REQUEST_SET_RECOGNIZING_MODE:
       bubble->SetRecognizingMode();
       break;
     case REQUEST_SET_MESSAGE:
       bubble->SetMessage(text);
       break;
     case REQUEST_SET_INPUT_VOLUME:
-      bubble->SetInputVolume(volume);
+      bubble->SetInputVolume(volume, noise_volume);
       break;
     case REQUEST_CLOSE:
       if (current_bubble_caller_id_ == caller_id)
         current_bubble_caller_id_ = 0;
       UpdateTabContentsSubscription(caller_id, BUBBLE_REMOVED);
       delete bubble;
       bubbles_.erase(caller_id);
       break;
     default:
       NOTREACHED();
@@ skipping 35 matching lines @@
 void SpeechInputBubbleController::InvokeDelegateButtonClicked(
     int caller_id, SpeechInputBubble::Button button) {
   delegate_->InfoBubbleButtonClicked(caller_id, button);
 }
 
 void SpeechInputBubbleController::InvokeDelegateFocusChanged(int caller_id) {
   delegate_->InfoBubbleFocusChanged(caller_id);
 }
 
 }  // namespace speech_input