Refactoring of chrome speech recognition architecture (CL1.6)

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"
@@ skipping 87 matching lines @@
 ChromeSpeechRecognitionManagerDelegate::ChromeSpeechRecognitionManagerDelegate()
     : bubble_controller_(new SpeechRecognitionBubbleController(
           ALLOW_THIS_IN_INITIALIZER_LIST(this))) {
 }
 
 ChromeSpeechRecognitionManagerDelegate::
     ~ChromeSpeechRecognitionManagerDelegate() {
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowRecognitionRequested(
-    int caller_id,
+    int session_id,
     int render_process_id,
     int render_view_id,
     const gfx::Rect& element_rect) {
-  bubble_controller_->CreateBubble(caller_id, render_process_id,
+  bubble_controller_->CreateBubble(session_id, render_process_id,
                                    render_view_id, element_rect);
 }
 
 void ChromeSpeechRecognitionManagerDelegate::GetRequestInfo(
     bool* can_report_metrics,
     std::string* request_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();
 }
 
-void ChromeSpeechRecognitionManagerDelegate::ShowWarmUp(int caller_id) {
-  bubble_controller_->SetBubbleWarmUpMode(caller_id);
+void ChromeSpeechRecognitionManagerDelegate::ShowWarmUp(int session_id) {
+  bubble_controller_->SetBubbleWarmUpMode(session_id);
 }
 
-void ChromeSpeechRecognitionManagerDelegate::ShowRecognizing(int caller_id) {
-  bubble_controller_->SetBubbleRecognizingMode(caller_id);
+void ChromeSpeechRecognitionManagerDelegate::ShowRecognizing(int session_id) {
+  bubble_controller_->SetBubbleRecognizingMode(session_id);
 }
 
-void ChromeSpeechRecognitionManagerDelegate::ShowRecording(int caller_id) {
-  bubble_controller_->SetBubbleRecordingMode(caller_id);
+void ChromeSpeechRecognitionManagerDelegate::ShowRecording(int session_id) {
+  bubble_controller_->SetBubbleRecordingMode(session_id);
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowInputVolume(
-    int caller_id, float volume, float noise_volume) {
-  bubble_controller_->SetBubbleInputVolume(caller_id, volume, noise_volume);
+    int session_id, float volume, float noise_volume) {
+  bubble_controller_->SetBubbleInputVolume(session_id, volume, noise_volume);
 }
 
-void ChromeSpeechRecognitionManagerDelegate::ShowMicError(int caller_id,
-                                                    MicError error) {
+void ChromeSpeechRecognitionManagerDelegate::ShowMicError(int session_id,
+                                                          MicError error) {
   switch (error) {
     case MIC_ERROR_NO_DEVICE_AVAILABLE:
       bubble_controller_->SetBubbleMessage(
-          caller_id, l10n_util::GetStringUTF16(IDS_SPEECH_INPUT_NO_MIC));
+          session_id, l10n_util::GetStringUTF16(IDS_SPEECH_INPUT_NO_MIC));
       break;
 
     case MIC_ERROR_DEVICE_IN_USE:
       bubble_controller_->SetBubbleMessage(
-          caller_id, l10n_util::GetStringUTF16(IDS_SPEECH_INPUT_MIC_IN_USE));
+          session_id, l10n_util::GetStringUTF16(IDS_SPEECH_INPUT_MIC_IN_USE));
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void ChromeSpeechRecognitionManagerDelegate::ShowRecognizerError(
-    int caller_id, content::SpeechRecognitionErrorCode error) {
+    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(
-          caller_id,
+          session_id,
           l10n_util::GetStringUTF16(error_message_map[i].message_id));
       return;
     }
   }
 
   NOTREACHED() << "unknown error " << error;
 }
 
-void ChromeSpeechRecognitionManagerDelegate::DoClose(int caller_id) {
-  bubble_controller_->CloseBubble(caller_id);
+void ChromeSpeechRecognitionManagerDelegate::DoClose(int session_id) {
+  bubble_controller_->CloseBubble(session_id);
 }
 
 void ChromeSpeechRecognitionManagerDelegate::InfoBubbleButtonClicked(
-    int caller_id, SpeechRecognitionBubble::Button button) {
+    int session_id, SpeechRecognitionBubble::Button button) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (button == SpeechRecognitionBubble::BUTTON_CANCEL) {
     SpeechRecognitionManager::GetInstance()->CancelRecognitionForRequest(
-        caller_id);
+        session_id);
   } else if (button == SpeechRecognitionBubble::BUTTON_TRY_AGAIN) {
     SpeechRecognitionManager::GetInstance()->StartRecognitionForRequest(
-        caller_id);
+        session_id);
   }
 }
 
 void ChromeSpeechRecognitionManagerDelegate::InfoBubbleFocusChanged(
-    int caller_id) {
+    int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  SpeechRecognitionManager::GetInstance()->FocusLostForRequest(caller_id);
+  SpeechRecognitionManager::GetInstance()->FocusLostForRequest(session_id);
 }
 
 }  // namespace speech