Fix code style and gyp files in cast to build cast_unittest

media/cast/audio_sender/audio_encoder.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 "media/cast/audio_sender/audio_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_defines.h"
@@ skipping 17 matching lines @@
         frequency_(frequency),
         cast_thread_(cast_thread),
         last_timestamp_(0) {}
 
   virtual int32 SendData(
       webrtc::FrameType /*frame_type*/,
       uint8 /*payload_type*/,
       uint32 timestamp,
       const uint8* payload_data,
       uint16 payload_size,
-      const webrtc::RTPFragmentationHeader* /*fragmentation*/) {
+      const webrtc::RTPFragmentationHeader* /*fragmentation*/) OVERRIDE {
     scoped_ptr<EncodedAudioFrame> audio_frame(new EncodedAudioFrame());
     audio_frame->codec = codec_;
     audio_frame->samples = timestamp - last_timestamp_;
     DCHECK(audio_frame->samples <= kMaxNumberOfSamples);
     last_timestamp_ = timestamp;
     audio_frame->data.insert(audio_frame->data.begin(),
                              payload_data,
                              payload_data + payload_size);
 
     cast_thread_->PostTask(CastThread::MAIN, FROM_HERE,
@@ skipping 54 matching lines @@
     default:
       DCHECK(false) << "Codec must be specified for audio encoder";
       return;
   }
   if (audio_encoder_->RegisterSendCodec(send_codec) != 0) {
     DCHECK(false) << "Invalid webrtc return value; failed to register codec";
   }
 }
 
 AudioEncoder::~AudioEncoder() {
-  webrtc::AudioCodingModule::Destroy(audio_encoder_);
 }
 
 // Called from main cast thread.
 void AudioEncoder::InsertRawAudioFrame(
     const PcmAudioFrame* audio_frame,
     const base::TimeTicks& recorded_time,
     const FrameEncodedCallback& frame_encoded_callback,
     const base::Closure release_callback) {
   cast_thread_->PostTask(CastThread::AUDIO_ENCODER, FROM_HERE,
       base::Bind(&AudioEncoder::EncodeAudioFrameThread, this, audio_frame,
           recorded_time, frame_encoded_callback, release_callback));
 }
 
 // Called from cast audio encoder thread.
 void AudioEncoder::EncodeAudioFrameThread(
     const PcmAudioFrame* audio_frame,
     const base::TimeTicks& recorded_time,
     const FrameEncodedCallback& frame_encoded_callback,
     const base::Closure release_callback) {
   DCHECK(cast_thread_->CurrentlyOn(CastThread::AUDIO_ENCODER));
   int samples_per_10ms = audio_frame->frequency / 100;
-  int number_of_10ms_blocks = audio_frame->samples.size() /
+  size_t number_of_10ms_blocks = audio_frame->samples.size() /
       (samples_per_10ms * audio_frame->channels);
   DCHECK(webrtc::AudioFrame::kMaxDataSizeSamples > samples_per_10ms)
       << "webrtc sanity check failed";
 
-  for (int i = 0; i < number_of_10ms_blocks; ++i) {
+  for (size_t i = 0; i < number_of_10ms_blocks; ++i) {
     webrtc::AudioFrame webrtc_audio_frame;
     webrtc_audio_frame.timestamp_ = timestamp_;
 
     // Due to the webrtc::AudioFrame declaration we need to copy our data into
     // the webrtc structure.
     memcpy(&webrtc_audio_frame.data_[0],
            &audio_frame->samples[i * samples_per_10ms * audio_frame->channels],
            samples_per_10ms * audio_frame->channels * sizeof(int16));
     webrtc_audio_frame.samples_per_channel_ = samples_per_10ms;
     webrtc_audio_frame.sample_rate_hz_ = audio_frame->frequency;
     webrtc_audio_frame.num_channels_ = audio_frame->channels;
 
     // webrtc::AudioCodingModule is thread safe.
     if (audio_encoder_->Add10MsData(webrtc_audio_frame) != 0) {
       DCHECK(false) << "Invalid webrtc return value";
     }
     timestamp_ += samples_per_10ms;
   }
   // We are done with the audio frame release it.
   cast_thread_->PostTask(CastThread::MAIN, FROM_HERE, release_callback);
 
   // Note:
   // Not all insert of 10 ms will generate a callback with encoded data.
   webrtc_encoder_callback_->SetEncodedCallbackInfo(recorded_time,
                                                    &frame_encoded_callback);
-  for (int i = 0; i < number_of_10ms_blocks; ++i) {
+  for (size_t i = 0; i < number_of_10ms_blocks; ++i) {
     audio_encoder_->Process();
   }
 }
 
 }  // namespace media
 }  // namespace cast