content/browser: Move speech code into content namespace.

content/browser/speech/speech_recognizer.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.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/time.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/speech/audio_buffer.h"
 #include "content/browser/speech/google_one_shot_remote_engine.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_grammar.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::SpeechRecognitionError;
-using content::SpeechRecognitionEventListener;
-using content::SpeechRecognitionGrammar;
-using content::SpeechRecognitionResult;
 using media::AudioInputController;
 using media::AudioManager;
 using media::AudioParameters;
 using media::ChannelLayout;
 
+namespace content {
 namespace {
 
 // The following constants are related to the volume level indicator shown in
 // the UI for recorded audio.
 // Multiplier used when new volume is greater than previous level.
 const float kUpSmoothingFactor = 1.0f;
 // Multiplier used when new volume is lesser than previous level.
 const float kDownSmoothingFactor = 0.7f;
 // RMS dB value of a maximum (unclipped) sine wave for int16 samples.
 const float kAudioMeterMaxDb = 90.31f;
 // This value corresponds to RMS dB for int16 with 6 most-significant-bits = 0.
 // Values lower than this will display as empty level-meter.
 const float kAudioMeterMinDb = 30.0f;
 const float kAudioMeterDbRange = kAudioMeterMaxDb - kAudioMeterMinDb;
 
 // Maximum level to draw to display unclipped meter. (1.0f displays clipping.)
 const float kAudioMeterRangeMaxUnclipped = 47.0f / 48.0f;
 
 // Returns true if more than 5% of the samples are at min or max value.
-bool DetectClipping(const speech::AudioChunk& chunk) {
+bool DetectClipping(const AudioChunk& chunk) {
   const int num_samples = chunk.NumSamples();
   const int16* samples = chunk.SamplesData16();
   const int kThreshold = num_samples / 20;
   int clipping_samples = 0;
 
   for (int i = 0; i < num_samples; ++i) {
     if (samples[i] <= -32767 || samples[i] >= 32767) {
       if (++clipping_samples > kThreshold)
         return true;
     }
   }
   return false;
 }
 
 void KeepAudioControllerRefcountedForDtor(scoped_refptr<AudioInputController>) {
 }
 
 }  // namespace
 
-namespace speech {
-
 const int SpeechRecognizer::kAudioSampleRate = 16000;
 const ChannelLayout SpeechRecognizer::kChannelLayout =
     media::CHANNEL_LAYOUT_MONO;
 const int SpeechRecognizer::kNumBitsPerAudioSample = 16;
 const int SpeechRecognizer::kNoSpeechTimeoutMs = 8000;
 const int SpeechRecognizer::kEndpointerEstimationTimeMs = 300;
 media::AudioManager* SpeechRecognizer::audio_manager_for_tests_ = NULL;
 
 COMPILE_ASSERT(SpeechRecognizer::kNumBitsPerAudioSample % 8 == 0,
                kNumBitsPerAudioSample_must_be_a_multiple_of_8);
@@ skipping 105 matching lines @@
   event_args.audio_data = new AudioChunk(data, static_cast<size_t>(size),
                                          kNumBitsPerAudioSample / 8);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizer::DispatchEvent,
                                      this, event_args));
 }
 
 void SpeechRecognizer::OnAudioClosed(AudioInputController*) {}
 
 void SpeechRecognizer::OnSpeechRecognitionEngineResult(
-    const content::SpeechRecognitionResult& result) {
+    const SpeechRecognitionResult& result) {
   FSMEventArgs event_args(EVENT_ENGINE_RESULT);
   event_args.engine_result = result;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizer::DispatchEvent,
                                      this, event_args));
 }
 
 void SpeechRecognizer::OnSpeechRecognitionEngineError(
-    const content::SpeechRecognitionError& error) {
+    const SpeechRecognitionError& error) {
   FSMEventArgs event_args(EVENT_ENGINE_ERROR);
   event_args.engine_error = error;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizer::DispatchEvent,
                                      this, event_args));
 }
 
 // -----------------------  Core FSM implementation ---------------------------
 // TODO(primiano): After the changes in the media package (r129173), this class
 // slightly violates the SpeechRecognitionEventListener interface contract. In
@@ skipping 182 matching lines @@
                                  audio_manager_for_tests_ :
                                  BrowserMainLoop::GetAudioManager();
   DCHECK(audio_manager != NULL);
 
   DVLOG(1) << "SpeechRecognizer starting audio capture.";
   num_samples_recorded_ = 0;
   audio_level_ = 0;
   listener_->OnRecognitionStart(session_id_);
 
   if (!audio_manager->HasAudioInputDevices()) {
-    return Abort(SpeechRecognitionError(
-        content::SPEECH_RECOGNITION_ERROR_AUDIO,
-        content::SPEECH_AUDIO_ERROR_DETAILS_NO_MIC));
+    return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_AUDIO,
+                                        SPEECH_AUDIO_ERROR_DETAILS_NO_MIC));
   }
 
   if (audio_manager->IsRecordingInProcess()) {
-    return Abort(SpeechRecognitionError(
-        content::SPEECH_RECOGNITION_ERROR_AUDIO,
-        content::SPEECH_AUDIO_ERROR_DETAILS_IN_USE));
+    return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_AUDIO,
+                                        SPEECH_AUDIO_ERROR_DETAILS_IN_USE));
   }
 
   const int samples_per_packet = (kAudioSampleRate *
       recognition_engine_->GetDesiredAudioChunkDurationMs()) / 1000;
   AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
                          kAudioSampleRate, kNumBitsPerAudioSample,
                          samples_per_packet);
   audio_controller_ = AudioInputController::Create(audio_manager, this, params);
 
   if (audio_controller_.get() == NULL) {
-    return Abort(
-        SpeechRecognitionError(content::SPEECH_RECOGNITION_ERROR_AUDIO));
+    return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_AUDIO));
   }
 
   // The endpointer needs to estimate the environment/background noise before
   // starting to treat the audio as user input. We wait in the state
   // ESTIMATING_ENVIRONMENT until such interval has elapsed before switching
   // to user input mode.
   endpointer_.SetEnvironmentEstimationMode();
   audio_controller_->Record();
   return STATE_STARTING;
 }
@@ skipping 24 matching lines @@
     return STATE_ESTIMATING_ENVIRONMENT;
   }
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::DetectUserSpeechOrTimeout(const FSMEventArgs&) {
   if (endpointer_.DidStartReceivingSpeech()) {
     listener_->OnSoundStart(session_id_);
     return STATE_RECOGNIZING;
   } else if (GetElapsedTimeMs() >= kNoSpeechTimeoutMs) {
-    return Abort(
-        SpeechRecognitionError(content::SPEECH_RECOGNITION_ERROR_NO_SPEECH));
+    return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_NO_SPEECH));
   }
   return STATE_WAITING_FOR_SPEECH;
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::DetectEndOfSpeech(const FSMEventArgs& event_args) {
   if (endpointer_.speech_input_complete())
     return StopCaptureAndWaitForResult(event_args);
   return STATE_RECOGNIZING;
 }
@@ skipping 10 matching lines @@
     listener_->OnSoundEnd(session_id_);
 
   listener_->OnAudioEnd(session_id_);
   return STATE_WAITING_FINAL_RESULT;
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::AbortSilently(const FSMEventArgs& event_args) {
   DCHECK_NE(event_args.event, EVENT_AUDIO_ERROR);
   DCHECK_NE(event_args.event, EVENT_ENGINE_ERROR);
-  return Abort(
-      SpeechRecognitionError(content::SPEECH_RECOGNITION_ERROR_NONE));
+  return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_NONE));
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::AbortWithError(const FSMEventArgs& event_args) {
   if (event_args.event == EVENT_AUDIO_ERROR) {
-    return Abort(
-        SpeechRecognitionError(content::SPEECH_RECOGNITION_ERROR_AUDIO));
+    return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_AUDIO));
   } else if (event_args.event == EVENT_ENGINE_ERROR) {
     return Abort(event_args.engine_error);
   }
-  return Abort(
-      SpeechRecognitionError(content::SPEECH_RECOGNITION_ERROR_ABORTED));
+  return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_ABORTED));
 }
 
 SpeechRecognizer::FSMState SpeechRecognizer::Abort(
     const SpeechRecognitionError& error) {
   if (IsCapturingAudio())
     CloseAudioControllerAsynchronously();
 
   DVLOG(1) << "SpeechRecognizer canceling recognition. ";
 
   // The recognition engine is initialized only after STATE_STARTING.
   if (state_ > STATE_STARTING) {
     DCHECK(recognition_engine_.get() != NULL);
     recognition_engine_->EndRecognition();
   }
 
   if (state_ > STATE_WAITING_FOR_SPEECH && state_ < STATE_WAITING_FINAL_RESULT)
     listener_->OnSoundEnd(session_id_);
 
   if (state_ > STATE_STARTING && state_ < STATE_WAITING_FINAL_RESULT)
     listener_->OnAudioEnd(session_id_);
 
-  if (error.code != content::SPEECH_RECOGNITION_ERROR_NONE)
+  if (error.code != SPEECH_RECOGNITION_ERROR_NONE)
     listener_->OnRecognitionError(session_id_, error);
 
   listener_->OnRecognitionEnd(session_id_);
 
   return STATE_IDLE;
 }
 
 SpeechRecognizer::FSMState SpeechRecognizer::ProcessIntermediateResult(
     const FSMEventArgs& event_args) {
   // Provisional results can occur only during continuous (non one-shot) mode.
@@ skipping 101 matching lines @@
 
 void SpeechRecognizer::SetAudioManagerForTests(
     AudioManager* audio_manager) {
   audio_manager_for_tests_ = audio_manager;
 }
 
 SpeechRecognizer::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value),
       audio_error_code(0),
       audio_data(NULL),
-      engine_error(content::SPEECH_RECOGNITION_ERROR_NONE) {
+      engine_error(SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizer::FSMEventArgs::~FSMEventArgs() {
 }
 
-}  // namespace speech
+}  // namespace content