content/browser: Move speech code into content namespace.

content/browser/speech/audio_encoder.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/audio_encoder.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "content/browser/speech/audio_buffer.h"
 #include "third_party/flac/flac.h"
 #include "third_party/speex/speex.h"
 
-using std::string;
-using speech::AudioChunk;
-
+namespace content {
 namespace {
 
 //-------------------------------- FLACEncoder ---------------------------------
 
 const char* const kContentTypeFLAC = "audio/x-flac; rate=";
 const int kFLACCompressionLevel = 0;  // 0 for speed
 
-class FLACEncoder : public speech::AudioEncoder {
+class FLACEncoder : public AudioEncoder {
  public:
   FLACEncoder(int sampling_rate, int bits_per_sample);
   virtual ~FLACEncoder();
   virtual void Encode(const AudioChunk& raw_audio) OVERRIDE;
   virtual void Flush() OVERRIDE;
 
  private:
   static FLAC__StreamEncoderWriteStatus WriteCallback(
       const FLAC__StreamEncoder* encoder,
       const FLAC__byte buffer[],
@@ skipping 68 matching lines @@
 //-------------------------------- SpeexEncoder --------------------------------
 
 const char* const kContentTypeSpeex = "audio/x-speex-with-header-byte; rate=";
 const int kSpeexEncodingQuality = 8;
 const int kMaxSpeexFrameLength = 110;  // (44kbps rate sampled at 32kHz).
 
 // Since the frame length gets written out as a byte in the encoded packet,
 // make sure it is within the byte range.
 COMPILE_ASSERT(kMaxSpeexFrameLength <= 0xFF, invalidLength);
 
-class SpeexEncoder : public speech::AudioEncoder {
+class SpeexEncoder : public AudioEncoder {
  public:
   explicit SpeexEncoder(int sampling_rate, int bits_per_sample);
   virtual ~SpeexEncoder();
   virtual void Encode(const AudioChunk& raw_audio) OVERRIDE;
   virtual void Flush() OVERRIDE {}
 
  private:
   void* encoder_state_;
   SpeexBits bits_;
   int samples_per_frame_;
@@ skipping 39 matching lines @@
     int frame_length = speex_bits_write(&bits_, encoded_frame_data_ + 1,
                                         kMaxSpeexFrameLength);
     encoded_frame_data_[0] = static_cast<char>(frame_length);
     encoded_audio_buffer_.Enqueue(
         reinterpret_cast<uint8*>(&encoded_frame_data_[0]), frame_length + 1);
   }
 }
 
 }  // namespace
 
-namespace speech {
-
 AudioEncoder* AudioEncoder::Create(Codec codec,
                                    int sampling_rate,
                                    int bits_per_sample) {
   if (codec == CODEC_FLAC)
     return new FLACEncoder(sampling_rate, bits_per_sample);
   return new SpeexEncoder(sampling_rate, bits_per_sample);
 }
 
 AudioEncoder::AudioEncoder(const std::string& mime_type, int bits_per_sample)
     : encoded_audio_buffer_(1), /* Byte granularity of encoded samples. */
       mime_type_(mime_type),
       bits_per_sample_(bits_per_sample) {
 }
 
 AudioEncoder::~AudioEncoder() {
 }
 
 scoped_refptr<AudioChunk> AudioEncoder::GetEncodedDataAndClear() {
   return encoded_audio_buffer_.DequeueAll();
 }
 
-}  // namespace speech
+}  // namespace content