Renamed speech input implementation from to speech_recognition_*. The namespace has been renamed fr…

chrome/browser/speech/speech_input_extension_manager.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/speech_input_extension_manager.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/profiles/profile_keyed_service_factory.h"
 #include "chrome/browser/speech/speech_input_extension_notification.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
-#include "content/public/browser/speech_input_manager.h"
+#include "content/public/browser/speech_recognition_manager.h"
 #include "content/public/browser/speech_recognizer.h"
-#include "content/public/common/speech_input_result.h"
+#include "content/public/common/speech_recognition_result.h"
 
 using content::BrowserThread;
-using content::SpeechInputManager;
+using content::SpeechRecognitionHypothesis;
+using content::SpeechRecognitionManager;
 
 namespace {
 
 const char kErrorNoRecordingDeviceFound[] = "noRecordingDeviceFound";
 const char kErrorRecordingDeviceInUse[] = "recordingDeviceInUse";
 const char kErrorUnableToStart[] = "unableToStart";
 const char kErrorRequestDenied[] = "requestDenied";
 const char kErrorRequestInProgress[] = "requestInProgress";
 const char kErrorInvalidOperation[] = "invalidOperation";
 
@@ skipping 190 matching lines @@
 }
 
 void SpeechInputExtensionManager::ResetToIdleState() {
   VLOG(1) << "State changed to idle. Deassociating any extensions.";
   state_ = kIdle;
   extension_id_in_use_.clear();
 }
 
 void SpeechInputExtensionManager::SetRecognitionResult(
     int caller_id,
-    const content::SpeechInputResult& result) {
+    const content::SpeechRecognitionResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(caller_id, kSpeechCallerId);
 
   // Stopping will start the disassociation with the extension.
   // Make a copy to report the results to the proper one.
   std::string extension_id = extension_id_in_use_;
   ForceStopOnIOThread();
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::SetRecognitionResultOnUIThread,
       this, result, extension_id));
 }
 
 void SpeechInputExtensionManager::SetRecognitionResultOnUIThread(
-    const content::SpeechInputResult& result,
+    const content::SpeechRecognitionResult& result,
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ListValue args;
   DictionaryValue* js_event = new DictionaryValue();
   args.Append(js_event);
 
   ListValue* js_hypothesis_array = new ListValue();
   js_event->Set(kHypothesesKey, js_hypothesis_array);
 
   for (size_t i = 0; i < result.hypotheses.size(); ++i) {
-    const content::SpeechInputHypothesis& hypothesis = result.hypotheses[i];
+    const SpeechRecognitionHypothesis& hypothesis = result.hypotheses[i];
 
     DictionaryValue* js_hypothesis_object = new DictionaryValue();
     js_hypothesis_array->Append(js_hypothesis_object);
 
     js_hypothesis_object->SetString(kUtteranceKey,
         UTF16ToUTF8(hypothesis.utterance));
     js_hypothesis_object->SetDouble(kConfidenceKey,
         hypothesis.confidence);
   }
 
@@ skipping 49 matching lines @@
   }
 
   VLOG(1) << "Sending start notification";
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_RECORDING_STARTED,
       content::Source<Profile>(profile_),
       content::Details<std::string>(&extension_id_in_use_));
 }
 
 void SpeechInputExtensionManager::OnRecognizerError(
-    int caller_id, content::SpeechInputError error) {
+    int caller_id, content::SpeechRecognitionErrorCode error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(caller_id, kSpeechCallerId);
   VLOG(1) << "OnRecognizerError: " << error;
 
   base::AutoLock auto_lock(state_lock_);
   if (state_ == kShutdown)
     return;
 
   // Release the recognizer object.
   GetSpeechInputExtensionInterface()->StopRecording(true);
 
   std::string event_error_code;
   bool report_to_event = true;
 
   switch (error) {
-    case content::SPEECH_INPUT_ERROR_NONE:
+    case content::SPEECH_RECOGNITION_ERROR_NONE:
       break;
 
-    case content::SPEECH_INPUT_ERROR_AUDIO:
+    case content::SPEECH_RECOGNITION_ERROR_AUDIO:
       if (state_ == kStarting) {
         event_error_code = kErrorUnableToStart;
         report_to_event = false;
       } else {
         event_error_code = kErrorCaptureError;
       }
       break;
 
-    case content::SPEECH_INPUT_ERROR_NETWORK:
+    case content::SPEECH_RECOGNITION_ERROR_NETWORK:
       event_error_code = kErrorNetworkError;
       break;
 
-    case content::SPEECH_INPUT_ERROR_BAD_GRAMMAR:
+    case content::SPEECH_RECOGNITION_ERROR_BAD_GRAMMAR:
       // No error is returned on invalid language, for example.
       // To avoid confusion about when this is would be fired, the invalid
       // params error is not being exposed to the onError event.
       event_error_code = kErrorUnableToStart;
       break;
 
-    case content::SPEECH_INPUT_ERROR_NO_SPEECH:
+    case content::SPEECH_RECOGNITION_ERROR_NO_SPEECH:
       event_error_code = kErrorNoSpeechHeard;
       break;
 
-    case content::SPEECH_INPUT_ERROR_NO_MATCH:
+    case content::SPEECH_RECOGNITION_ERROR_NO_MATCH:
       event_error_code = kErrorNoResults;
       break;
 
     // The remaining kErrorAborted case should never be returned by the server.
     default:
       NOTREACHED();
   }
 
   if (!event_error_code.empty()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
@@ skipping 152 matching lines @@
     return;
 
   if (!GetSpeechInputExtensionInterface()->HasAudioInputDevices()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&SpeechInputExtensionManager::DispatchError, this,
                    std::string(kErrorNoRecordingDeviceFound), false));
     return;
   }
 
-  if (GetSpeechInputExtensionInterface()->IsRecordingInProcess()) {
+  if (GetSpeechInputExtensionInterface()->IsCapturingAudio()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&SpeechInputExtensionManager::DispatchError, this,
         std::string(kErrorRecordingDeviceInUse), false));
     return;
   }
 
   GetSpeechInputExtensionInterface()->StartRecording(
       this, context_getter, kSpeechCallerId, language, grammar,
       filter_profanities);
 }
 
 bool SpeechInputExtensionManager::HasAudioInputDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  return SpeechInputManager::GetInstance()->HasAudioInputDevices();
+  return SpeechRecognitionManager::GetInstance()->HasAudioInputDevices();
 }
 
-bool SpeechInputExtensionManager::IsRecordingInProcess() {
+bool SpeechInputExtensionManager::IsCapturingAudio() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  return SpeechInputManager::GetInstance()->IsRecordingInProcess();
+  return SpeechRecognitionManager::GetInstance()->IsCapturingAudio();
 }
 
 void SpeechInputExtensionManager::IsRecording(
     const IsRecordingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::IsRecordingOnIOThread,
                  this, callback));
 }
 
 void SpeechInputExtensionManager::IsRecordingOnIOThread(
     const IsRecordingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool result = GetSpeechInputExtensionInterface()->IsRecordingInProcess();
+  bool result = GetSpeechInputExtensionInterface()->IsCapturingAudio();
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&SpeechInputExtensionManager::IsRecordingOnUIThread,
                  this, callback, result));
 }
 
 void SpeechInputExtensionManager::IsRecordingOnUIThread(
     const IsRecordingCallback& callback,
     bool result) {
   BrowserThread::CurrentlyOn(BrowserThread::UI);
@@ skipping 116 matching lines @@
       base::Bind(&SpeechInputExtensionManager::SetInputVolumeOnUIThread,
       this, volume));
 }
 
 void SpeechInputExtensionManager::SetInputVolumeOnUIThread(
     float volume) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(notification_.get());
   notification_->SetVUMeterVolume(volume);
 }