Cast: Refactoring Cast API's

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 34 matching lines @@
     DCHECK_GT(num_channels_, 0);
     DCHECK_GT(samples_per_10ms_, 0);
     DCHECK_EQ(sampling_rate % 100, 0);
     DCHECK_LE(samples_per_10ms_ * num_channels_,
               transport::EncodedAudioFrame::kMaxNumberOfSamples);
 
     if (num_channels_ <= 0 || samples_per_10ms_ <= 0 ||
         sampling_rate % 100 != 0 ||
         samples_per_10ms_ * num_channels_ >
             transport::EncodedAudioFrame::kMaxNumberOfSamples) {
-      initialization_status_ = STATUS_INVALID_AUDIO_CONFIGURATION;
+      cast_initialization_cb_ = STATUS_INVALID_AUDIO_CONFIGURATION;
     } else {
-      initialization_status_ = STATUS_INITIALIZED;
+      cast_initialization_cb_ = STATUS_AUDIO_INITIALIZED;
     }
   }
 
   virtual ~ImplBase() {}
 
   CastInitializationStatus InitializationResult() const {
-    return initialization_status_;
+    return cast_initialization_cb_;
   }
 
   void LogAudioFrameEvent(uint32 rtp_timestamp,
                           uint32 frame_id,
                           CastLoggingEvent type) {
     cast_environment_->Logging()->InsertFrameEvent(
         cast_environment_->Clock()->NowTicks(), type, rtp_timestamp, frame_id);
   }
 
   void EncodeAudio(const AudioBus* audio_bus,
@@ skipping 74 matching lines @@
                                          int source_offset,
                                          int buffer_fill_offset,
                                          int num_samples) = 0;
   virtual bool EncodeFromFilledBuffer(std::string* out) = 0;
 
   CastEnvironment* const cast_environment_;
   const transport::AudioCodec codec_;
   const int num_channels_;
   const int samples_per_10ms_;
   const FrameEncodedCallback callback_;
-  CastInitializationStatus initialization_status_;
+  CastInitializationStatus cast_initialization_cb_;
 
  private:
   // In the case where a call to EncodeAudio() cannot completely fill the
   // buffer, this points to the position at which to populate data in a later
   // call.
   int buffer_fill_end_;
 
   // A counter used to label EncodedAudioFrames.
   uint32 frame_id_;
 
@@ skipping 15 matching lines @@
            int bitrate,
            const FrameEncodedCallback& callback)
       : ImplBase(cast_environment,
                  transport::kOpus,
                  num_channels,
                  sampling_rate,
                  callback),
         encoder_memory_(new uint8[opus_encoder_get_size(num_channels)]),
         opus_encoder_(reinterpret_cast<OpusEncoder*>(encoder_memory_.get())),
         buffer_(new float[num_channels * samples_per_10ms_]) {
-    if (ImplBase::initialization_status_ != STATUS_INITIALIZED) {
+    if (ImplBase::cast_initialization_cb_ != STATUS_AUDIO_INITIALIZED) {
       return;
     }
 
     CHECK_EQ(
         opus_encoder_init(
             opus_encoder_, sampling_rate, num_channels, OPUS_APPLICATION_AUDIO),
         OPUS_OK);
     if (bitrate <= 0) {
       // Note: As of 2013-10-31, the encoder in "auto bitrate" mode would use a
       // variable bitrate up to 102kbps for 2-channel, 48 kHz audio and a 10 ms
@@ skipping 103 matching lines @@
 };
 
 AudioEncoder::AudioEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
     const AudioSenderConfig& audio_config,
     const FrameEncodedCallback& frame_encoded_callback)
     : cast_environment_(cast_environment) {
   // Note: It doesn't matter which thread constructs AudioEncoder, just so long
   // as all calls to InsertAudio() are by the same thread.
   insert_thread_checker_.DetachFromThread();
-
   switch (audio_config.codec) {
     case transport::kOpus:
       impl_.reset(new OpusImpl(cast_environment,
                                audio_config.channels,
                                audio_config.frequency,
                                audio_config.bitrate,
                                frame_encoded_callback));
       break;
     case transport::kPcm16:
       impl_.reset(new Pcm16Impl(cast_environment,
                                 audio_config.channels,
                                 audio_config.frequency,
                                 frame_encoded_callback));
       break;
     default:
       NOTREACHED() << "Unsupported or unspecified codec for audio encoder";
       break;
   }
 }
 
 AudioEncoder::~AudioEncoder() {}
 
 CastInitializationStatus AudioEncoder::InitializationResult() const {
+  DCHECK(insert_thread_checker_.CalledOnValidThread());
   if (impl_) {
     return impl_->InitializationResult();
   }
   return STATUS_UNSUPPORTED_AUDIO_CODEC;
 }
 
 void AudioEncoder::InsertAudio(const AudioBus* audio_bus,
                                const base::TimeTicks& recorded_time,
                                const base::Closure& done_callback) {
   DCHECK(insert_thread_checker_.CalledOnValidThread());
@@ skipping 14 matching lines @@
 
 void AudioEncoder::EncodeAudio(const AudioBus* audio_bus,
                                const base::TimeTicks& recorded_time,
                                const base::Closure& done_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::AUDIO_ENCODER));
   impl_->EncodeAudio(audio_bus, recorded_time, done_callback);
 }
 
 }  // namespace cast
 }  // namespace media