[Cast] Halt AudioSender transmission when too many frames are in-flight.

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"
 #include "base/location.h"
-#include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "media/base/audio_bus.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
-#include "media/cast/logging/logging_defines.h"
 #include "third_party/opus/src/include/opus.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // The fixed number of audio frames per second and, inversely, the duration of
 // one frame's worth of samples.
 const int kFramesPerSecond = 100;
 const int kFrameDurationMillis = 1000 / kFramesPerSecond;  // No remainder!
 
 // Threshold used to decide whether audio being delivered to the encoder is
 // coming in too slow with respect to the capture timestamps.
 const int kUnderrunThresholdMillis = 3 * kFrameDurationMillis;
 
-void LogAudioFrameEncodedEvent(
-    const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
-    base::TimeTicks event_time,
-    media::cast::RtpTimestamp rtp_timestamp,
-    uint32 frame_id,
-    size_t frame_size) {
-  if (!cast_environment->CurrentlyOn(CastEnvironment::MAIN)) {
-    cast_environment->PostTask(
-        CastEnvironment::MAIN,
-        FROM_HERE,
-        base::Bind(&LogAudioFrameEncodedEvent,
-                   cast_environment, event_time,
-                   rtp_timestamp, frame_id, frame_size));
-    return;
-  }
-  cast_environment->Logging()->InsertEncodedFrameEvent(
-      event_time, media::cast::FRAME_ENCODED, media::cast::AUDIO_EVENT,
-      rtp_timestamp, frame_id,
-      static_cast<int>(frame_size), /* key_frame - unused */ false,
-      /*target_bitrate - unused*/ 0);
-}
-
 }  // namespace
 
 
 // Base class that handles the common problem of feeding one or more AudioBus'
 // data into a buffer and then, once the buffer is full, encoding the signal and
 // emitting an EncodedFrame via the FrameEncodedCallback.
 //
 // Subclasses complete the implementation by handling the actual encoding
 // details.
 class AudioEncoder::ImplBase
@@ skipping 75 matching lines @@
 
       scoped_ptr<transport::EncodedFrame> audio_frame(
           new transport::EncodedFrame());
       audio_frame->dependency = transport::EncodedFrame::KEY;
       audio_frame->frame_id = frame_id_;
       audio_frame->referenced_frame_id = frame_id_;
       audio_frame->rtp_timestamp = frame_rtp_timestamp_;
       audio_frame->reference_time = frame_capture_time_;
 
       if (EncodeFromFilledBuffer(&audio_frame->data)) {
-        LogAudioFrameEncodedEvent(cast_environment_,
-                                  cast_environment_->Clock()->NowTicks(),
-                                  audio_frame->rtp_timestamp,
-                                  audio_frame->frame_id,
-                                  audio_frame->data.size());
         cast_environment_->PostTask(
             CastEnvironment::MAIN,
             FROM_HERE,
             base::Bind(callback_, base::Passed(&audio_frame)));
       }
 
       // Reset the internal buffer, frame ID, and timestamps for the next frame.
       buffer_fill_end_ = 0;
       ++frame_id_;
       frame_rtp_timestamp_ += samples_per_frame_;
@@ skipping 234 matching lines @@
   cast_environment_->PostTask(CastEnvironment::AUDIO,
                               FROM_HERE,
                               base::Bind(&AudioEncoder::ImplBase::EncodeAudio,
                                          impl_,
                                          base::Passed(&audio_bus),
                                          recorded_time));
 }
 
 }  // namespace cast
 }  // namespace media