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

content/browser/speech/speech_recognizer_impl.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 "content/browser/speech/speech_recognizer_impl.h"
 
 #include "base/bind.h"
 #include "base/time.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/public/browser/speech_recognizer_delegate.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/common/speech_input_result.h"
+#include "content/public/common/speech_recognition_result.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserMainLoop;
 using content::BrowserThread;
 using content::SpeechRecognizer;
 using content::SpeechRecognizerDelegate;
 using media::AudioInputController;
 using std::string;
 
 namespace {
@@ skipping 31 matching lines @@
 
 SpeechRecognizer* SpeechRecognizer::Create(
     SpeechRecognizerDelegate* delegate,
     int caller_id,
     const std::string& language,
     const std::string& grammar,
     net::URLRequestContextGetter* context_getter,
     bool filter_profanities,
     const std::string& hardware_info,
     const std::string& origin_url) {
-  return new speech_input::SpeechRecognizerImpl(
+  return new speech::SpeechRecognizerImpl(
       delegate, caller_id, language, grammar, context_getter,
       filter_profanities, hardware_info, origin_url);
 }
 
-namespace speech_input {
+namespace speech {
 
 const int SpeechRecognizerImpl::kAudioSampleRate = 16000;
 const int SpeechRecognizerImpl::kAudioPacketIntervalMs = 100;
 const ChannelLayout SpeechRecognizerImpl::kChannelLayout = CHANNEL_LAYOUT_MONO;
 const int SpeechRecognizerImpl::kNumBitsPerAudioSample = 16;
 const int SpeechRecognizerImpl::kNoSpeechTimeoutSec = 8;
 const int SpeechRecognizerImpl::kEndpointerEstimationTimeMs = 300;
 
 SpeechRecognizerImpl::SpeechRecognizerImpl(
     SpeechRecognizerDelegate* delegate,
@@ skipping 121 matching lines @@
 
 void SpeechRecognizerImpl::HandleOnError(int error_code) {
   LOG(WARNING) << "SpeechRecognizer::HandleOnError, code=" << error_code;
 
   // Check if we are still recording before canceling recognition, as
   // recording might have been stopped after this error was posted to the queue
   // by |OnError|.
   if (!audio_controller_.get())
     return;
 
-  InformErrorAndCancelRecognition(content::SPEECH_INPUT_ERROR_AUDIO);
+  InformErrorAndCancelRecognition(content::SPEECH_RECOGNITION_ERROR_AUDIO);
 }
 
 void SpeechRecognizerImpl::OnData(AudioInputController* controller,
                                   const uint8* data, uint32 size) {
   if (size == 0)  // This could happen when recording stops and is normal.
     return;
 
   string* str_data = new string(reinterpret_cast<const char*>(data), size);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizerImpl::HandleOnData,
@@ skipping 43 matching lines @@
       endpointer_.SetUserInputMode();
       delegate_->DidCompleteEnvironmentEstimation(caller_id_);
     }
     return;  // No more processing since we are still estimating environment.
   }
 
   // Check if we have waited too long without hearing any speech.
   bool speech_was_heard_after_packet = endpointer_.DidStartReceivingSpeech();
   if (!speech_was_heard_after_packet &&
       num_samples_recorded_ >= kNoSpeechTimeoutSec * kAudioSampleRate) {
-    InformErrorAndCancelRecognition(content::SPEECH_INPUT_ERROR_NO_SPEECH);
+    InformErrorAndCancelRecognition(
+        content::SPEECH_RECOGNITION_ERROR_NO_SPEECH);
     return;
   }
 
   if (!speech_was_heard_before_packet && speech_was_heard_after_packet)
     delegate_->DidStartReceivingSpeech(caller_id_);
 
   // Calculate the input volume to display in the UI, smoothing towards the
   // new level.
   float level = (rms - kAudioMeterMinDb) /
       (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
@@ skipping 10 matching lines @@
       kAudioMeterRangeMaxUnclipped);
 
   delegate_->SetInputVolume(caller_id_, did_clip ? 1.0f : audio_level_,
                             noise_level);
 
   if (endpointer_.speech_input_complete())
     StopRecording();
 }
 
 void SpeechRecognizerImpl::SetRecognitionResult(
-    const content::SpeechInputResult& result) {
-  if (result.error != content::SPEECH_INPUT_ERROR_NONE) {
+    const content::SpeechRecognitionResult& result) {
+  if (result.error != content::SPEECH_RECOGNITION_ERROR_NONE) {
     InformErrorAndCancelRecognition(result.error);
     return;
   }
 
   // Guard against the delegate freeing us until we finish our job.
   scoped_refptr<SpeechRecognizerImpl> me(this);
   delegate_->SetRecognitionResult(caller_id_, result);
   delegate_->DidCompleteRecognition(caller_id_);
 }
 
 void SpeechRecognizerImpl::InformErrorAndCancelRecognition(
-    content::SpeechInputError error) {
-  DCHECK_NE(error, content::SPEECH_INPUT_ERROR_NONE);
+    content::SpeechRecognitionErrorCode error) {
+  DCHECK_NE(error, content::SPEECH_RECOGNITION_ERROR_NONE);
   CancelRecognition();
 
   // Guard against the delegate freeing us until we finish our job.
   scoped_refptr<SpeechRecognizerImpl> me(this);
   delegate_->OnRecognizerError(caller_id_, error);
 }
 
 void SpeechRecognizerImpl::CloseAudioControllerSynchronously() {
   VLOG(1) << "SpeechRecognizer stopping record.";
 
   // TODO(satish): investigate the possibility to utilize the closure
   // and switch to async. version of this method. Compare with how
   // it's done in e.g. the AudioRendererHost.
   base::WaitableEvent closed_event(true, false);
   audio_controller_->Close(base::Bind(&base::WaitableEvent::Signal,
                            base::Unretained(&closed_event)));
   closed_event.Wait();
   audio_controller_ = NULL;  // Releases the ref ptr.
 }
 
 void SpeechRecognizerImpl::SetAudioManagerForTesting(
     AudioManager* audio_manager) {
   audio_manager_ = audio_manager;
 }
 
-}  // namespace speech_input
+}  // namespace speech