Cast: Cleaning up framer code; resolving TODOs

// TODO(pwestin): we can deprecate the timeout argument.
The timeout argument passed to 
Framer::GetEncodedVideoFrame and Framer::GetEncodedAudioFrame is removed since is was not used.

// TODO(pwestin): only release if we have a complete frame
VideoReceiver::GetEncodedVideoFrame and AudioReceiver::PlayoutTimeout()
Update logic such that a frame is only checked if it can be released if the incoming packet make a frame complete.

Review URL: https://codereview.chromium.org/26686004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@227923 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 68 insertions, 107 deletions

diff --git a/media/cast/audio_receiver/audio_receiver.cc b/media/cast/audio_receiver/audio_receiver.cc
index b239dcc..fde0421 100644
--- a/media/cast/audio_receiver/audio_receiver.cc
+++ b/media/cast/audio_receiver/audio_receiver.cc
@@ -150,19 +150,18 @@ void AudioReceiver::IncomingParsedRtpPacket(const uint8* payload_data,
                                             rtp_header);
     return;
   }
-  if (audio_buffer_) {
-    DCHECK(!audio_decoder_) << "Invalid internal state";
-    audio_buffer_->InsertPacket(payload_data, payload_size, rtp_header);
-    if (queued_encoded_callbacks_.empty()) {
-      // No pending callback.
-      return;
-    }
-    AudioFrameEncodedCallback callback = queued_encoded_callbacks_.front();
-    queued_encoded_callbacks_.pop_front();
-    cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
-        base::Bind(&AudioReceiver::GetEncodedAudioFrame,
-            weak_factory_.GetWeakPtr(), callback));
-  }
+  DCHECK(audio_buffer_) << "Invalid internal state";
+  DCHECK(!audio_decoder_) << "Invalid internal state";
+  bool complete = audio_buffer_->InsertPacket(payload_data, payload_size,
+                                              rtp_header);
+  if (!complete) return;  // Audio frame not complete; wait for more packets.
+  if (queued_encoded_callbacks_.empty()) return;  // No pending callback.
+
+  AudioFrameEncodedCallback callback = queued_encoded_callbacks_.front();
+  queued_encoded_callbacks_.pop_front();
+  cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
+      base::Bind(&AudioReceiver::GetEncodedAudioFrame,
+          weak_factory_.GetWeakPtr(), callback));
 }
 
 void AudioReceiver::GetRawAudioFrame(int number_of_10ms_blocks,
@@ -213,9 +212,8 @@ void AudioReceiver::PlayoutTimeout() {
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
   scoped_ptr<EncodedAudioFrame> encoded_frame(new EncodedAudioFrame());
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
-  if (!audio_buffer_->GetEncodedAudioFrame(now, encoded_frame.get(),
+  if (!audio_buffer_->GetEncodedAudioFrame(encoded_frame.get(),
                                            &rtp_timestamp, &next_frame)) {
     // We have no audio frames. Wait for new packet(s).
     DCHECK(false);
@@ -234,9 +232,8 @@ void AudioReceiver::GetEncodedAudioFrame(
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
   scoped_ptr<EncodedAudioFrame> encoded_frame(new EncodedAudioFrame());
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
-  if (!audio_buffer_->GetEncodedAudioFrame(now, encoded_frame.get(),
+  if (!audio_buffer_->GetEncodedAudioFrame(encoded_frame.get(),
                                            &rtp_timestamp, &next_frame)) {
     // We have no audio frames. Wait for new packet(s).
     VLOG(1) << "Wait for more audio packets in frame";
diff --git a/media/cast/framer/frame_id_map.h b/media/cast/framer/frame_id_map.h
index 6bf72a0..cecaaeb 100644
--- a/media/cast/framer/frame_id_map.h
+++ b/media/cast/framer/frame_id_map.h
@@ -25,7 +25,7 @@ class FrameInfo {
             bool key_frame);
   ~FrameInfo();
 
-  // Returns true if frame is complete after the insert.
+  // Returns true if packet is inserted.
   bool InsertPacket(uint16 packet_id);
   bool Complete() const;
   void GetMissingPackets(bool newest_frame,
diff --git a/media/cast/framer/framer.cc b/media/cast/framer/framer.cc
index 2366915..dbb803e 100644
--- a/media/cast/framer/framer.cc
+++ b/media/cast/framer/framer.cc
@@ -16,8 +16,7 @@ Framer::Framer(base::TickClock* clock,
                uint32 ssrc,
                bool decoder_faster_than_max_frame_rate,
                int max_unacked_frames)
-    : clock_(clock),
-      decoder_faster_than_max_frame_rate_(decoder_faster_than_max_frame_rate),
+    : decoder_faster_than_max_frame_rate_(decoder_faster_than_max_frame_rate),
       cast_msg_builder_(new CastMessageBuilder(clock, incoming_payload_feedback,
           &frame_id_map_, ssrc, decoder_faster_than_max_frame_rate,
           max_unacked_frames)) {
@@ -26,11 +25,11 @@ Framer::Framer(base::TickClock* clock,
 
 Framer::~Framer() {}
 
-void Framer::InsertPacket(const uint8* payload_data,
+bool Framer::InsertPacket(const uint8* payload_data,
                           size_t payload_size,
                           const RtpCastHeader& rtp_header) {
   bool complete = false;
-  if (!frame_id_map_.InsertPacket(rtp_header, &complete)) return;
+  if (!frame_id_map_.InsertPacket(rtp_header, &complete)) return false;
 
   // Does this packet belong to a new frame?
   FrameList::iterator it = frames_.find(rtp_header.frame_id);
@@ -49,11 +48,11 @@ void Framer::InsertPacket(const uint8* payload_data,
     cast_msg_builder_->CompleteFrameReceived(rtp_header.frame_id,
                                              rtp_header.is_key_frame);
   }
+  return complete;
 }
 
 // This does not release the frame.
-bool Framer::GetEncodedAudioFrame(const base::TimeTicks& timeout,
-                                  EncodedAudioFrame* audio_frame,
+bool Framer::GetEncodedAudioFrame(EncodedAudioFrame* audio_frame,
                                   uint32* rtp_timestamp,
                                   bool* next_frame) {
   uint8 frame_id;
@@ -62,8 +61,6 @@ bool Framer::GetEncodedAudioFrame(const base::TimeTicks& timeout,
     // We have our next frame.
     *next_frame = true;
   } else {
-    if (WaitForNextFrame(timeout)) return false;
-
     if (!frame_id_map_.NextAudioFrameAllowingMissingFrames(&frame_id)) {
       return false;
     }
@@ -78,8 +75,7 @@ bool Framer::GetEncodedAudioFrame(const base::TimeTicks& timeout,
 }
 
 // This does not release the frame.
-bool Framer::GetEncodedVideoFrame(const base::TimeTicks& timeout,
-                                  EncodedVideoFrame* video_frame,
+bool Framer::GetEncodedVideoFrame(EncodedVideoFrame* video_frame,
                                   uint32* rtp_timestamp,
                                   bool* next_frame) {
   uint8 frame_id;
@@ -88,8 +84,6 @@ bool Framer::GetEncodedVideoFrame(const base::TimeTicks& timeout,
     // We have our next frame.
     *next_frame = true;
   } else {
-    if (WaitForNextFrame(timeout)) return false;
-
     // Check if we can skip frames when our decoder is too slow.
     if (!decoder_faster_than_max_frame_rate_) return false;
 
@@ -106,14 +100,6 @@ bool Framer::GetEncodedVideoFrame(const base::TimeTicks& timeout,
   return it->second->GetEncodedVideoFrame(video_frame, rtp_timestamp);
 }
 
-bool Framer::WaitForNextFrame(const base::TimeTicks& timeout) const {
-  base::TimeDelta wait_time = timeout - clock_->NowTicks();
-  if (wait_time.InMilliseconds() > 0)
-    return true;
-
-  return false;
-}
-
 void Framer::Reset() {
   frame_id_map_.Clear();
   frames_.clear();
diff --git a/media/cast/framer/framer.h b/media/cast/framer/framer.h
index c0acb4a..e208ab1 100644
--- a/media/cast/framer/framer.h
+++ b/media/cast/framer/framer.h
@@ -32,7 +32,9 @@ class Framer {
          int max_unacked_frames);
   ~Framer();
 
-  void InsertPacket(const uint8* payload_data,
+  // Return true when receiving the last packet in a frame, creating a
+  // complete frame.
+  bool InsertPacket(const uint8* payload_data,
                     size_t payload_size,
                     const RtpCastHeader& rtp_header);
 
@@ -40,13 +42,11 @@ class Framer {
   // frame.
   // Returns false if the frame does not exist or if the frame is not complete
   // within the given time frame.
-  bool GetEncodedVideoFrame(const base::TimeTicks& timeout,
-                            EncodedVideoFrame* video_frame,
+  bool GetEncodedVideoFrame(EncodedVideoFrame* video_frame,
                             uint32* rtp_timestamp,
                             bool* next_frame);
 
-  bool GetEncodedAudioFrame(const base::TimeTicks& timeout,
-                            EncodedAudioFrame* audio_frame,
+  bool GetEncodedAudioFrame(EncodedAudioFrame* audio_frame,
                             uint32* rtp_timestamp,
                             bool* next_frame);
 
@@ -58,10 +58,6 @@ class Framer {
   void SendCastMessage();
 
  private:
-  // Return true if we should wait.
-  bool WaitForNextFrame(const base::TimeTicks& timeout) const;
-
-  base::TickClock* const clock_;  // Not owned by this class.
   const bool decoder_faster_than_max_frame_rate_;
   FrameList frames_;
   FrameIdMap frame_id_map_;
diff --git a/media/cast/framer/framer_unittest.cc b/media/cast/framer/framer_unittest.cc
index bd8337f..d4bc942 100644
--- a/media/cast/framer/framer_unittest.cc
+++ b/media/cast/framer/framer_unittest.cc
@@ -47,8 +47,7 @@ TEST_F(FramerTest, EmptyState) {
   EncodedVideoFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                             &next_frame));
 }
 
@@ -56,16 +55,15 @@ TEST_F(FramerTest, AlwaysStartWithKey) {
   EncodedVideoFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
 
   // Insert non key first frame.
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                             &next_frame));
   rtp_header_.frame_id = 1;
   rtp_header_.is_key_frame = true;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(1, frame.frame_id);
@@ -77,12 +75,11 @@ TEST_F(FramerTest, CompleteFrame) {
   EncodedVideoFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
 
   // start with a complete key frame.
   rtp_header_.is_key_frame = true;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(0, frame.frame_id);
@@ -94,14 +91,14 @@ TEST_F(FramerTest, CompleteFrame) {
   rtp_header_.is_key_frame = false;
   rtp_header_.max_packet_id = 2;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                             &next_frame));
 
   // Complete delta - can't skip, as incomplete sequence.
   ++rtp_header_.frame_id;
   rtp_header_.max_packet_id = 0;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                             &next_frame));
 }
 
@@ -109,12 +106,11 @@ TEST_F(FramerTest, ContinuousSequence) {
   EncodedVideoFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
 
   // start with a complete key frame.
   rtp_header_.is_key_frame = true;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(0, frame.frame_id);
@@ -125,7 +121,7 @@ TEST_F(FramerTest, ContinuousSequence) {
   rtp_header_.frame_id = 2;
   rtp_header_.is_key_frame = false;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                             &next_frame));
 }
 
@@ -134,13 +130,12 @@ TEST_F(FramerTest, Wrap) {
   EncodedVideoFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
 
   // Start with a complete key frame.
   rtp_header_.is_key_frame = true;
   rtp_header_.frame_id = 255;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(255, frame.frame_id);
@@ -150,7 +145,7 @@ TEST_F(FramerTest, Wrap) {
   rtp_header_.is_key_frame = false;
   rtp_header_.frame_id = 0;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(0, frame.frame_id);
@@ -161,13 +156,12 @@ TEST_F(FramerTest, Reset) {
   EncodedVideoFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
 
   // Start with a complete key frame.
   rtp_header_.is_key_frame = true;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
   framer_.Reset();
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                             &next_frame));
 }
 
@@ -175,19 +169,18 @@ TEST_F(FramerTest, RequireKeyAfterReset) {
   EncodedVideoFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
   framer_.Reset();
 
   // Start with a complete key frame.
   rtp_header_.is_key_frame = false;
   rtp_header_.frame_id = 0;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                             &next_frame));
   rtp_header_.frame_id = 1;
   rtp_header_.is_key_frame = true;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
 }
@@ -200,8 +193,7 @@ TEST_F(FramerTest, BasicNonLastReferenceId) {
   rtp_header_.frame_id = 0;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
 
-  base::TimeTicks timeout;
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   framer_.ReleaseFrame(frame.frame_id);
 
@@ -211,13 +203,7 @@ TEST_F(FramerTest, BasicNonLastReferenceId) {
   rtp_header_.frame_id = 5;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
 
-  timeout += base::TimeDelta::FromMilliseconds(kFrameTimeMillisecond);
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
-                                            &next_frame));
-  testing_clock_.Advance(
-        base::TimeDelta::FromMilliseconds(kFrameTimeMillisecond));
-
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_FALSE(next_frame);
 }
@@ -227,7 +213,7 @@ TEST_F(FramerTest, InOrderReferenceFrameSelection) {
   EncodedVideoFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
+
   rtp_header_.is_key_frame = true;
   rtp_header_.frame_id = 0;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
@@ -244,16 +230,16 @@ TEST_F(FramerTest, InOrderReferenceFrameSelection) {
   rtp_header_.is_reference = true;
   rtp_header_.reference_frame_id = 0;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_EQ(0, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(1, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_FALSE(next_frame);
   EXPECT_EQ(4, frame.frame_id);
@@ -262,14 +248,14 @@ TEST_F(FramerTest, InOrderReferenceFrameSelection) {
   rtp_header_.frame_id = 2;
   rtp_header_.packet_id = 1;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_FALSE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                             &next_frame));
   rtp_header_.is_reference = false;
   rtp_header_.frame_id = 5;
   rtp_header_.packet_id = 0;
   rtp_header_.max_packet_id = 0;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedVideoFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(5, frame.frame_id);
@@ -279,12 +265,12 @@ TEST_F(FramerTest, AudioWrap) {
   // All audio frames are marked as key frames.
   EncodedAudioFrame frame;
   uint32_t rtp_timestamp;
-  base::TimeTicks timeout;
   bool next_frame = false;
   rtp_header_.is_key_frame = true;
   rtp_header_.frame_id = 254;
+
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(254, frame.frame_id);
@@ -297,13 +283,13 @@ TEST_F(FramerTest, AudioWrap) {
   rtp_header_.frame_id = 0;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
 
-  EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(255, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
 
-  EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(0, frame.frame_id);
@@ -315,13 +301,12 @@ TEST_F(FramerTest, AudioWrapWithMissingFrame) {
   EncodedAudioFrame frame;
   uint32_t rtp_timestamp;
   bool next_frame = false;
-  base::TimeTicks timeout;
 
   // Insert and get first packet.
   rtp_header_.is_key_frame = true;
   rtp_header_.frame_id = 253;
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
-  EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(253, frame.frame_id);
@@ -334,12 +319,12 @@ TEST_F(FramerTest, AudioWrapWithMissingFrame) {
   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
 
   // Get third and fourth packets.
-  EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_FALSE(next_frame);
   EXPECT_EQ(255, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
-  EXPECT_TRUE(framer_.GetEncodedAudioFrame(timeout, &frame, &rtp_timestamp,
+  EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
                                            &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(0, frame.frame_id);
diff --git a/media/cast/video_receiver/video_receiver.cc b/media/cast/video_receiver/video_receiver.cc
index 40f5630..530e412 100644
--- a/media/cast/video_receiver/video_receiver.cc
+++ b/media/cast/video_receiver/video_receiver.cc
@@ -126,7 +126,7 @@ VideoReceiver::VideoReceiver(scoped_refptr<CastEnvironment> cast_environment,
       video_config.max_frame_rate / 1000;
   DCHECK(max_unacked_frames) << "Invalid argument";
 
-  framer_.reset(new Framer(cast_environment_->Clock(),
+  framer_.reset(new Framer(cast_environment->Clock(),
                            incoming_payload_feedback_.get(),
                            video_config.incoming_ssrc,
                            video_config.decoder_faster_than_max_frame_rate,
@@ -206,10 +206,8 @@ void VideoReceiver::GetEncodedVideoFrame(
   scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
-  // TODO(pwestin): we can deprecate the timeout argument.
-  if (!framer_->GetEncodedVideoFrame(now, encoded_frame.get(), &rtp_timestamp,
+  if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
                                      &next_frame)) {
     // We have no video frames. Wait for new packet(s).
     queued_encoded_callbacks_.push_back(callback);
@@ -277,11 +275,9 @@ void VideoReceiver::PlayoutTimeout() {
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
   scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
-  base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
-  // TODO(pwestin): we can deprecate the timeout argument.
-  if (!framer_->GetEncodedVideoFrame(now, encoded_frame.get(),
-                                     &rtp_timestamp, &next_frame)) {
+  if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
+                                     &next_frame)) {
     // We have no video frames. Wait for new packet(s).
     // A timer should not be set unless we have a video frame; and if that frame
     // was pulled early the callback should have been removed.
@@ -360,15 +356,16 @@ void VideoReceiver::IncomingPacket(const uint8* packet, int length,
 void VideoReceiver::IncomingRtpPacket(const uint8* payload_data,
                                       int payload_size,
                                       const RtpCastHeader& rtp_header) {
-  // TODO(pwestin): only release if we have a complete frame
-  framer_->InsertPacket(payload_data, payload_size, rtp_header);
-  if (!queued_encoded_callbacks_.empty()) {
-    VideoFrameEncodedCallback callback = queued_encoded_callbacks_.front();
-    queued_encoded_callbacks_.pop_front();
-    cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
-        base::Bind(&VideoReceiver::GetEncodedVideoFrame,
-            weak_factory_.GetWeakPtr(), callback));
-  }
+  bool complete = framer_->InsertPacket(payload_data, payload_size, rtp_header);
+
+  if (!complete) return;  // Video frame not complete; wait for more packets.
+  if (queued_encoded_callbacks_.empty()) return;  // No pending callback.
+
+  VideoFrameEncodedCallback callback = queued_encoded_callbacks_.front();
+  queued_encoded_callbacks_.pop_front();
+  cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
+      base::Bind(&VideoReceiver::GetEncodedVideoFrame,
+          weak_factory_.GetWeakPtr(), callback));
 }
 
 // Send a cast feedback message. Actual message created in the framer (cast