Rename WebKit namespace to blink (part 3)

content/renderer/media/android/audio_decoder_android.cc

 // Copyright 2013 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/renderer/media/android/audio_decoder_android.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <sys/mman.h>
@@ skipping 95 matching lines @@
 // basic guide to the WAVE file format.
 class WAVEDecoder {
  public:
   WAVEDecoder(const uint8* data, size_t data_size);
   ~WAVEDecoder();
 
   // Try to decode the data as a WAVE file.  If the data is a supported
   // WAVE file, |destination_bus| is filled with the decoded data and
   // DecodeWAVEFile returns true.  Otherwise, DecodeWAVEFile returns
   // false.
-  bool DecodeWAVEFile(WebKit::WebAudioBus* destination_bus);
+  bool DecodeWAVEFile(blink::WebAudioBus* destination_bus);
 
  private:
   // Minimum number of bytes in a WAVE file to hold all of the data we
   // need to interpret it as a WAVE file.
   static const unsigned kMinimumWAVLength = 44;
 
   // Number of bytes in the chunk ID field.
   static const unsigned kChunkIDLength = 4;
 
   // Number of bytes in the chunk size field.
@@ skipping 23 matching lines @@
   // Read a WAVE chunk header including the chunk ID and chunk size.
   // Returns false if the header could not be read.
   bool ReadChunkHeader();
 
   // Read and parse the "fmt" chunk.  Returns false if the fmt chunk
   // could not be read or contained unsupported formats.
   bool ReadFMTChunk();
 
   // Read data chunk and save it to |destination_bus|.  Returns false
   // if the data chunk could not be read correctly.
-  bool CopyDataChunkToBus(WebKit::WebAudioBus* destination_bus);
+  bool CopyDataChunkToBus(blink::WebAudioBus* destination_bus);
 
   // The WAVE chunk ID that identifies the chunk.
   uint8_t chunk_id_[kChunkIDLength];
 
   // The number of bytes in the data portion of the chunk.
   size_t chunk_size_;
 
   // The current position within the WAVE file.
   const uint8_t* buffer_;
 
@@ skipping 115 matching lines @@
   // We only support 8, 16, and 24 bits per sample.
   if (bits_per_sample == 8 || bits_per_sample == 16 || bits_per_sample == 24) {
     bytes_per_sample_ = bits_per_sample / 8;
     return true;
   }
 
   DVLOG(1) << "Unsupported bits per sample: " << bits_per_sample;
   return false;
 }
 
-bool WAVEDecoder::CopyDataChunkToBus(WebKit::WebAudioBus* destination_bus) {
+bool WAVEDecoder::CopyDataChunkToBus(blink::WebAudioBus* destination_bus) {
   // The data chunk contains the audio data itself.
   if (!bytes_per_sample_ || bytes_per_sample_ > kMaximumBytesPerSample) {
     DVLOG(1) << "WARNING: data chunk without preceeding fmt chunk,"
              << " or invalid bytes per sample.";
     return false;
   }
 
   VLOG(0) << "Decoding WAVE file: " << number_of_channels_ << " channels, "
           << sample_rate_ << " kHz, "
           << chunk_size_ / bytes_per_sample_ / number_of_channels_
@@ skipping 12 matching lines @@
       int16_t sample = ReadPCMSample(buffer_);
 
       buffer_ += bytes_per_sample_;
       destination_bus->channelData(k)[m] = ConvertSampleToFloat(sample);
     }
   }
 
   return true;
 }
 
-bool WAVEDecoder::DecodeWAVEFile(WebKit::WebAudioBus* destination_bus) {
+bool WAVEDecoder::DecodeWAVEFile(blink::WebAudioBus* destination_bus) {
   // Parse and decode WAVE file. If we can't parse it, return false.
 
   if (buffer_ + kMinimumWAVLength > buffer_end_) {
     DVLOG(1) << "Buffer too small to contain full WAVE header: ";
     return false;
   }
 
   // Do we have a RIFF file?
   ReadChunkHeader();
   if (memcmp(chunk_id_, "RIFF", kChunkIDLength) != 0) {
@@ skipping 48 matching lines @@
   // If we get here, that means we didn't find a data chunk, so we
   // couldn't handle this WAVE file.
 
   return false;
 }
 
 // The number of frames is known so preallocate the destination
 // bus and copy the pcm data to the destination bus as it's being
 // received.
 static void CopyPcmDataToBus(int input_fd,
-                             WebKit::WebAudioBus* destination_bus,
+                             blink::WebAudioBus* destination_bus,
                              size_t number_of_frames,
                              unsigned number_of_channels,
                              double file_sample_rate) {
   destination_bus->initialize(number_of_channels,
                               number_of_frames,
                               file_sample_rate);
 
   int16_t pipe_data[PIPE_BUF / sizeof(int16_t)];
   size_t decoded_frames = 0;
   ssize_t nread;
@@ skipping 17 matching lines @@
   // number_of_frames is only an estimate.  Resize the buffer with the
   // actual number of received frames.
   if (decoded_frames < number_of_frames)
     destination_bus->resizeSmaller(decoded_frames);
 }
 
 // The number of frames is unknown, so keep reading and buffering
 // until there's no more data and then copy the data to the
 // destination bus.
 static void BufferAndCopyPcmDataToBus(int input_fd,
-                                      WebKit::WebAudioBus* destination_bus,
+                                      blink::WebAudioBus* destination_bus,
                                       unsigned number_of_channels,
                                       double file_sample_rate) {
   int16_t pipe_data[PIPE_BUF / sizeof(int16_t)];
   std::vector<int16_t> decoded_samples;
   ssize_t nread;
 
   while ((nread = HANDLE_EINTR(read(input_fd, pipe_data, sizeof(pipe_data)))) >
          0) {
     size_t samples_in_pipe = nread / sizeof(int16_t);
     if (decoded_samples.size() + samples_in_pipe > decoded_samples.capacity()) {
@@ skipping 24 matching lines @@
     }
     ++decoded_frames;
   }
 
   // number_of_frames is only an estimate.  Resize the buffer with the
   // actual number of received frames.
   if (decoded_frames < number_of_frames)
     destination_bus->resizeSmaller(decoded_frames);
 }
 
-static bool TryWAVEFileDecoder(WebKit::WebAudioBus* destination_bus,
+static bool TryWAVEFileDecoder(blink::WebAudioBus* destination_bus,
                                const uint8_t* encoded_data,
                                size_t data_size) {
   WAVEDecoder decoder(encoded_data, data_size);
 
   return decoder.DecodeWAVEFile(destination_bus);
 }
 
 // To decode audio data, we want to use the Android MediaCodec class.
 // But this can't run in a sandboxed process so we need initiate the
 // request to MediaCodec in the browser.  To do this, we create a
 // shared memory buffer that holds the audio data.  We send a message
 // to the browser to start the decoder using this buffer and one end
 // of a pipe.  The MediaCodec class will decode the data from the
 // shared memory and write the PCM samples back to us over a pipe.
-bool DecodeAudioFileData(WebKit::WebAudioBus* destination_bus, const char* data,
+bool DecodeAudioFileData(blink::WebAudioBus* destination_bus, const char* data,
                          size_t data_size, double sample_rate,
                          scoped_refptr<ThreadSafeSender> sender) {
   // Try to decode the data as a WAVE file first.  If it can't be
   // decoded, use MediaCodec.  See crbug.com/259048.
   if (TryWAVEFileDecoder(
           destination_bus, reinterpret_cast<const uint8_t*>(data), data_size)) {
     return true;
   }
 
   AudioDecoderIO audio_decoder(data, data_size);
@@ skipping 58 matching lines @@
     BufferAndCopyPcmDataToBus(input_fd,
                               destination_bus,
                               number_of_channels,
                               file_sample_rate);
   }
 
   return true;
 }
 
 }  // namespace content