Cast: Add rtp_timestamp to EncodedVideoFrame and update logging

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

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

17 files changed, 127 insertions, 147 deletions

diff --git a/media/cast/framer/frame_buffer.cc b/media/cast/framer/frame_buffer.cc
index 2fddf51..0c92047 100644
--- a/media/cast/framer/frame_buffer.cc
+++ b/media/cast/framer/frame_buffer.cc
@@ -83,17 +83,14 @@ bool FrameBuffer::GetEncodedAudioFrame(
 }
 
 bool FrameBuffer::GetEncodedVideoFrame(
-    transport::EncodedVideoFrame* video_frame,
-    uint32* rtp_timestamp) const {
+    transport::EncodedVideoFrame* video_frame) const {
   if (!Complete())
     return false;
-
-  *rtp_timestamp = rtp_timestamp_;
-
   // Frame is complete -> construct.
   video_frame->key_frame = is_key_frame_;
   video_frame->frame_id = frame_id_;
   video_frame->last_referenced_frame_id = last_referenced_frame_id_;
+  video_frame->rtp_timestamp = rtp_timestamp_;
 
   // Build the data vector.
   video_frame->data.clear();
diff --git a/media/cast/framer/frame_buffer.h b/media/cast/framer/frame_buffer.h
index 04ea943..65df021d 100644
--- a/media/cast/framer/frame_buffer.h
+++ b/media/cast/framer/frame_buffer.h
@@ -27,8 +27,7 @@ class FrameBuffer {
 
   bool GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame) const;
 
-  bool GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
-                            uint32* rtp_timestamp) const;
+  bool GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame) const;
 
   bool is_key_frame() const { return is_key_frame_; }
 
diff --git a/media/cast/framer/frame_buffer_unittest.cc b/media/cast/framer/frame_buffer_unittest.cc
index a407dca..c5af17e 100644
--- a/media/cast/framer/frame_buffer_unittest.cc
+++ b/media/cast/framer/frame_buffer_unittest.cc
@@ -30,12 +30,23 @@ class FrameBufferTest : public ::testing::Test {
   DISALLOW_COPY_AND_ASSIGN(FrameBufferTest);
 };
 
+TEST_F(FrameBufferTest, OnePacketInsertSanity) {
+  rtp_header_.webrtc.header.timestamp = 3000u;
+  rtp_header_.is_key_frame = true;
+  rtp_header_.frame_id = 5;
+  buffer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
+  transport::EncodedVideoFrame frame;
+  EXPECT_TRUE(buffer_.GetEncodedVideoFrame(&frame));
+  EXPECT_EQ(5u, frame.frame_id);
+  EXPECT_TRUE(frame.key_frame);
+  EXPECT_EQ(3000u, frame.rtp_timestamp);
+}
+
 TEST_F(FrameBufferTest, EmptyBuffer) {
   EXPECT_FALSE(buffer_.Complete());
   EXPECT_FALSE(buffer_.is_key_frame());
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
-  EXPECT_FALSE(buffer_.GetEncodedVideoFrame(&frame, &rtp_timestamp));
+  EXPECT_FALSE(buffer_.GetEncodedVideoFrame(&frame));
 }
 
 TEST_F(FrameBufferTest, DefaultOnePacketFrame) {
@@ -43,8 +54,7 @@ TEST_F(FrameBufferTest, DefaultOnePacketFrame) {
   EXPECT_TRUE(buffer_.Complete());
   EXPECT_FALSE(buffer_.is_key_frame());
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
-  EXPECT_TRUE(buffer_.GetEncodedVideoFrame(&frame, &rtp_timestamp));
+  EXPECT_TRUE(buffer_.GetEncodedVideoFrame(&frame));
   EXPECT_EQ(payload_.size(), frame.data.size());
 }
 
@@ -60,12 +70,11 @@ TEST_F(FrameBufferTest, MultiplePacketFrame) {
   EXPECT_TRUE(buffer_.Complete());
   EXPECT_TRUE(buffer_.is_key_frame());
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
-  EXPECT_TRUE(buffer_.GetEncodedVideoFrame(&frame, &rtp_timestamp));
+  EXPECT_TRUE(buffer_.GetEncodedVideoFrame(&frame));
   EXPECT_EQ(3 * payload_.size(), frame.data.size());
 }
 
-TEST_F(FrameBufferTest, InCompleteFrame) {
+TEST_F(FrameBufferTest, IncompleteFrame) {
   rtp_header_.max_packet_id = 4;
   buffer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
   ++rtp_header_.packet_id;
diff --git a/media/cast/framer/framer.cc b/media/cast/framer/framer.cc
index 5df3e62..ef9b207 100644
--- a/media/cast/framer/framer.cc
+++ b/media/cast/framer/framer.cc
@@ -93,7 +93,6 @@ bool Framer::GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame,
 
 // This does not release the frame.
 bool Framer::GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
-                                  uint32* rtp_timestamp,
                                   bool* next_frame) {
   uint32 frame_id;
   // Find frame id.
@@ -116,7 +115,7 @@ bool Framer::GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
   if (it == frames_.end())
     return false;
 
-  return it->second->GetEncodedVideoFrame(video_frame, rtp_timestamp);
+  return it->second->GetEncodedVideoFrame(video_frame);
 }
 
 void Framer::Reset() {
diff --git a/media/cast/framer/framer.h b/media/cast/framer/framer.h
index 7010015..eb67064 100644
--- a/media/cast/framer/framer.h
+++ b/media/cast/framer/framer.h
@@ -45,7 +45,6 @@ class Framer {
   // Returns false if the frame does not exist or if the frame is not complete
   // within the given time frame.
   bool GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
-                            uint32* rtp_timestamp,
                             bool* next_frame);
 
   bool GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame,
diff --git a/media/cast/framer/framer_unittest.cc b/media/cast/framer/framer_unittest.cc
index 50d7f28..d8c9b0d 100644
--- a/media/cast/framer/framer_unittest.cc
+++ b/media/cast/framer/framer_unittest.cc
@@ -41,15 +41,12 @@ class FramerTest : public ::testing::Test {
 
 TEST_F(FramerTest, EmptyState) {
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 }
 
 TEST_F(FramerTest, AlwaysStartWithKey) {
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
   bool duplicate = false;
@@ -58,15 +55,13 @@ TEST_F(FramerTest, AlwaysStartWithKey) {
   complete = framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   rtp_header_.frame_id = 1;
   rtp_header_.is_key_frame = true;
   complete = framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(1u, frame.frame_id);
   EXPECT_TRUE(frame.key_frame);
@@ -75,7 +70,6 @@ TEST_F(FramerTest, AlwaysStartWithKey) {
 
 TEST_F(FramerTest, CompleteFrame) {
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
   bool duplicate = false;
@@ -85,8 +79,7 @@ TEST_F(FramerTest, CompleteFrame) {
   complete = framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(0u, frame.frame_id);
   EXPECT_TRUE(frame.key_frame);
@@ -99,8 +92,7 @@ TEST_F(FramerTest, CompleteFrame) {
   complete = framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_FALSE(complete);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 
   // Complete delta - can't skip, as incomplete sequence.
   ++rtp_header_.frame_id;
@@ -108,13 +100,11 @@ TEST_F(FramerTest, CompleteFrame) {
   complete = framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 }
 
 TEST_F(FramerTest, DuplicatePackets) {
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
   bool duplicate = false;
@@ -127,8 +117,7 @@ TEST_F(FramerTest, DuplicatePackets) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_FALSE(complete);
   EXPECT_FALSE(duplicate);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 
   // Add same packet again in incomplete key frame.
   duplicate = false;
@@ -136,8 +125,7 @@ TEST_F(FramerTest, DuplicatePackets) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_FALSE(complete);
   EXPECT_TRUE(duplicate);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 
   // Complete key frame.
   rtp_header_.packet_id = 1;
@@ -146,8 +134,7 @@ TEST_F(FramerTest, DuplicatePackets) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
   EXPECT_FALSE(duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_EQ(0u, frame.frame_id);
 
   // Add same packet again in complete key frame.
@@ -156,8 +143,7 @@ TEST_F(FramerTest, DuplicatePackets) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_FALSE(complete);
   EXPECT_TRUE(duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_EQ(0u, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
 
@@ -170,8 +156,7 @@ TEST_F(FramerTest, DuplicatePackets) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_FALSE(complete);
   EXPECT_FALSE(duplicate);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 
   // Add same packet again in incomplete delta frame.
   duplicate = false;
@@ -179,8 +164,7 @@ TEST_F(FramerTest, DuplicatePackets) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_FALSE(complete);
   EXPECT_TRUE(duplicate);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 
   // Complete delta frame.
   rtp_header_.packet_id = 1;
@@ -189,8 +173,7 @@ TEST_F(FramerTest, DuplicatePackets) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
   EXPECT_FALSE(duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_EQ(1u, frame.frame_id);
 
   // Add same packet again in complete delta frame.
@@ -199,14 +182,12 @@ TEST_F(FramerTest, DuplicatePackets) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_FALSE(complete);
   EXPECT_TRUE(duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_EQ(1u, frame.frame_id);
 }
 
 TEST_F(FramerTest, ContinuousSequence) {
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
   bool duplicate = false;
@@ -216,8 +197,7 @@ TEST_F(FramerTest, ContinuousSequence) {
   complete = framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(0u, frame.frame_id);
   EXPECT_TRUE(frame.key_frame);
@@ -229,14 +209,12 @@ TEST_F(FramerTest, ContinuousSequence) {
   complete = framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 }
 
 TEST_F(FramerTest, Wrap) {
   // Insert key frame, frame_id = 255 (will jump to that)
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
 
@@ -245,8 +223,7 @@ TEST_F(FramerTest, Wrap) {
   rtp_header_.frame_id = 255u;
   framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(255u, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
@@ -256,8 +233,7 @@ TEST_F(FramerTest, Wrap) {
   rtp_header_.frame_id = 256;
   framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(256u, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
@@ -265,7 +241,6 @@ TEST_F(FramerTest, Wrap) {
 
 TEST_F(FramerTest, Reset) {
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool complete = false;
   bool duplicate = false;
@@ -276,13 +251,11 @@ TEST_F(FramerTest, Reset) {
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
   EXPECT_TRUE(complete);
   framer_.Reset();
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 }
 
 TEST_F(FramerTest, RequireKeyAfterReset) {
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
 
@@ -293,20 +266,17 @@ TEST_F(FramerTest, RequireKeyAfterReset) {
   rtp_header_.frame_id = 0u;
   framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   rtp_header_.frame_id = 1;
   rtp_header_.is_key_frame = true;
   framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_TRUE(next_frame);
 }
 
 TEST_F(FramerTest, BasicNonLastReferenceId) {
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
 
@@ -315,8 +285,7 @@ TEST_F(FramerTest, BasicNonLastReferenceId) {
   framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   framer_.ReleaseFrame(frame.frame_id);
 
   rtp_header_.is_key_frame = false;
@@ -326,15 +295,13 @@ TEST_F(FramerTest, BasicNonLastReferenceId) {
   framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_FALSE(next_frame);
 }
 
 TEST_F(FramerTest, InOrderReferenceFrameSelection) {
   // Create pattern: 0, 1, 4, 5.
   transport::EncodedVideoFrame frame;
-  uint32 rtp_timestamp;
   bool next_frame = false;
   bool duplicate = false;
 
@@ -358,17 +325,14 @@ TEST_F(FramerTest, InOrderReferenceFrameSelection) {
   rtp_header_.reference_frame_id = 0;
   framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_EQ(0u, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(1u, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_FALSE(next_frame);
   EXPECT_EQ(4u, frame.frame_id);
   framer_.ReleaseFrame(frame.frame_id);
@@ -377,16 +341,14 @@ TEST_F(FramerTest, InOrderReferenceFrameSelection) {
   rtp_header_.packet_id = 1;
   framer_.InsertPacket(
       payload_.data(), payload_.size(), rtp_header_, &duplicate);
-  EXPECT_FALSE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &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_, &duplicate);
-  EXPECT_TRUE(
-      framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp, &next_frame));
+  EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
   EXPECT_TRUE(next_frame);
   EXPECT_EQ(5u, frame.frame_id);
 }
diff --git a/media/cast/test/end2end_unittest.cc b/media/cast/test/end2end_unittest.cc
index f071abf..f2e62c6 100644
--- a/media/cast/test/end2end_unittest.cc
+++ b/media/cast/test/end2end_unittest.cc
@@ -1052,9 +1052,9 @@ TEST_F(End2EndTest, VideoLogging) {
   EXPECT_TRUE(event_it != event_log.end());
   event_log.erase(event_it);
 
-  // TODO(mikhal): Plumb this one through.
   event_it = std::find(event_log.begin(), event_log.end(), kVideoFrameDecoded);
-  EXPECT_TRUE(event_it == event_log.end());
+  EXPECT_TRUE(event_it != event_log.end());
+  event_log.erase(event_it);
 
   // Verify that there were no other events logged with respect to this frame.
   EXPECT_EQ(0u, event_log.size());
diff --git a/media/cast/transport/cast_transport_config.cc b/media/cast/transport/cast_transport_config.cc
index f7da700..2254cb7 100644
--- a/media/cast/transport/cast_transport_config.cc
+++ b/media/cast/transport/cast_transport_config.cc
@@ -30,7 +30,12 @@ CastTransportConfig::CastTransportConfig()
 
 CastTransportConfig::~CastTransportConfig() {}
 
-EncodedVideoFrame::EncodedVideoFrame() {}
+EncodedVideoFrame::EncodedVideoFrame()
+    : codec(kVp8),
+      key_frame(false),
+      frame_id(0),
+      last_referenced_frame_id(0),
+      rtp_timestamp(0) {}
 EncodedVideoFrame::~EncodedVideoFrame() {}
 
 EncodedAudioFrame::EncodedAudioFrame()
diff --git a/media/cast/transport/cast_transport_config.h b/media/cast/transport/cast_transport_config.h
index e89ee6f..16ab143 100644
--- a/media/cast/transport/cast_transport_config.h
+++ b/media/cast/transport/cast_transport_config.h
@@ -74,6 +74,7 @@ struct EncodedVideoFrame {
   bool key_frame;
   uint32 frame_id;
   uint32 last_referenced_frame_id;
+  uint32 rtp_timestamp;
   std::string data;
 };
 
diff --git a/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.cc b/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.cc
index a6f4f4f..f357c7a 100644
--- a/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.cc
+++ b/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer.cc
@@ -52,14 +52,11 @@ void RtpPacketizer::IncomingEncodedVideoFrame(
   DCHECK(!config_.audio) << "Invalid state";
   if (config_.audio) return;
 
-  // Timestamp is in 90 KHz for video.
-  rtp_timestamp_ = GetVideoRtpTimestamp(capture_time);
   time_last_sent_rtp_timestamp_ = capture_time;
-
   Cast(video_frame->key_frame,
        video_frame->frame_id,
        video_frame->last_referenced_frame_id,
-       rtp_timestamp_,
+       video_frame->rtp_timestamp,
        video_frame->data);
 }
 
@@ -100,6 +97,7 @@ void RtpPacketizer::Cast(bool is_key,
                          const std::string& data) {
   uint16 rtp_header_length = kCommonRtpHeaderLength + kCastRtpHeaderLength;
   uint16 max_length = config_.max_payload_length - rtp_header_length - 1;
+  rtp_timestamp_ = timestamp;
 
   // Split the payload evenly (round number up).
   size_t num_packets = (data.size() + max_length) / max_length;
diff --git a/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc b/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc
index 0fb50a4..ec344c0 100644
--- a/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc
+++ b/media/cast/transport/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc
@@ -35,7 +35,8 @@ class TestRtpPacketTransport : public PacketSender {
          packets_sent_(0),
          expected_number_of_packets_(0),
          expected_packet_id_(0),
-         expected_frame_id_(0) {}
+         expected_frame_id_(0),
+         expectd_rtp_timestamp_(0) {}
 
   void VerifyRtpHeader(const RtpCastTestHeader& rtp_header) {
     VerifyCommonRtpHeader(rtp_header);
@@ -45,7 +46,7 @@ class TestRtpPacketTransport : public PacketSender {
   void VerifyCommonRtpHeader(const RtpCastTestHeader& rtp_header) {
     EXPECT_EQ(kPayload, rtp_header.payload_type);
     EXPECT_EQ(sequence_number_, rtp_header.sequence_number);
-    EXPECT_EQ(kTimestampMs * 90, rtp_header.rtp_timestamp);
+    EXPECT_EQ(expectd_rtp_timestamp_, rtp_header.rtp_timestamp);
     EXPECT_EQ(config_.ssrc, rtp_header.ssrc);
     EXPECT_EQ(0, rtp_header.num_csrcs);
   }
@@ -78,6 +79,10 @@ class TestRtpPacketTransport : public PacketSender {
     expected_number_of_packets_ = expected_number_of_packets;
   }
 
+  void set_rtp_timestamp(uint32 rtp_timestamp) {
+    expectd_rtp_timestamp_ = rtp_timestamp;
+  }
+
   RtpPacketizerConfig config_;
   uint32 sequence_number_;
   int packets_sent_;
@@ -86,6 +91,7 @@ class TestRtpPacketTransport : public PacketSender {
   // Assuming packets arrive in sequence.
   int expected_packet_id_;
   uint32 expected_frame_id_;
+  uint32 expectd_rtp_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRtpPacketTransport);
 };
@@ -110,6 +116,8 @@ class RtpPacketizerTest : public ::testing::Test {
     video_frame_.frame_id = 0;
     video_frame_.last_referenced_frame_id = kStartFrameId;
     video_frame_.data.assign(kFrameSize, 123);
+    video_frame_.rtp_timestamp =
+        GetVideoRtpTimestamp(testing_clock_.NowTicks());
   }
 
   virtual ~RtpPacketizerTest() {}
@@ -137,6 +145,7 @@ class RtpPacketizerTest : public ::testing::Test {
 TEST_F(RtpPacketizerTest, SendStandardPackets) {
   int expected_num_of_packets = kFrameSize / kMaxPacketLength + 1;
   transport_->set_expected_number_of_packets(expected_num_of_packets);
+  transport_->set_rtp_timestamp(video_frame_.rtp_timestamp);
 
   base::TimeTicks time;
   time += base::TimeDelta::FromMilliseconds(kTimestampMs);
@@ -151,6 +160,7 @@ TEST_F(RtpPacketizerTest, Stats) {
   // Insert packets at varying lengths.
   int expected_num_of_packets = kFrameSize / kMaxPacketLength + 1;
   transport_->set_expected_number_of_packets(expected_num_of_packets);
+  transport_->set_rtp_timestamp(video_frame_.rtp_timestamp);
 
   testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kTimestampMs));
   rtp_packetizer_->IncomingEncodedVideoFrame(&video_frame_,
diff --git a/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc b/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
index ade419b..772817d 100644
--- a/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
+++ b/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
@@ -16,10 +16,13 @@ namespace media {
 namespace cast {
 
 void LogFrameDecodedEvent(CastEnvironment* const cast_environment,
+                          uint32 rtp_timestamp,
                           uint32 frame_id) {
-// TODO(mikhal): Sort out passing of rtp_timestamp.
-// cast_environment->Logging()->InsertFrameEvent(kVideoFrameDecoded,
-//      0, frame_id);
+  cast_environment->Logging()->InsertFrameEvent(
+      cast_environment->Clock()->NowTicks(),
+      kVideoFrameDecoded,
+      rtp_timestamp,
+      frame_id);
 }
 
 Vp8Decoder::Vp8Decoder(scoped_refptr<CastEnvironment> cast_environment)
@@ -100,11 +103,15 @@ bool Vp8Decoder::Decode(const transport::EncodedVideoFrame* encoded_frame,
   CopyPlane(VideoFrame::kVPlane, img->planes[VPX_PLANE_V],
             img->stride[VPX_PLANE_V], (img->d_h + 1) / 2, decoded_frame.get());
 
-  // Log:: Decoding complete (should be called from the main thread).
-  cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, base::Bind(
-      LogFrameDecodedEvent, cast_environment_,encoded_frame->frame_id));
-
   VLOG(1) << "Decoded frame " << frame_id_int;
+
+  // Update logging from the main thread.
+  cast_environment_->PostTask(CastEnvironment::MAIN,
+                              FROM_HERE,
+                              base::Bind(LogFrameDecodedEvent,
+                                         cast_environment_,
+                                         encoded_frame->rtp_timestamp,
+                                         encoded_frame->frame_id));
   // Frame decoded - return frame to the user via callback.
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(frame_decoded_cb, decoded_frame, render_time));
diff --git a/media/cast/video_receiver/video_receiver.cc b/media/cast/video_receiver/video_receiver.cc
index 21a3067..172964a 100644
--- a/media/cast/video_receiver/video_receiver.cc
+++ b/media/cast/video_receiver/video_receiver.cc
@@ -152,9 +152,13 @@ void VideoReceiver::DecodeVideoFrame(
     const base::TimeTicks& render_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // Hand the ownership of the encoded frame to the decode thread.
-  cast_environment_->PostTask(CastEnvironment::VIDEO_DECODER, FROM_HERE,
-      base::Bind(&VideoReceiver::DecodeVideoFrameThread, base::Unretained(this),
-                 base::Passed(&encoded_frame), render_time, callback));
+  cast_environment_->PostTask(CastEnvironment::VIDEO_DECODER,
+                              FROM_HERE,
+                              base::Bind(&VideoReceiver::DecodeVideoFrameThread,
+                                         base::Unretained(this),
+                                         base::Passed(&encoded_frame),
+                                         render_time,
+                                         callback));
 }
 
 // Utility function to run the decoder on a designated decoding thread.
@@ -202,8 +206,7 @@ void VideoReceiver::GetEncodedVideoFrame(
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
 
-  if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
-                                     &next_frame)) {
+  if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &next_frame)) {
     // We have no video frames. Wait for new packet(s).
     queued_encoded_callbacks_.push_back(callback);
     return;
@@ -216,10 +219,12 @@ void VideoReceiver::GetEncodedVideoFrame(
   }
 
   base::TimeTicks render_time;
-  if (PullEncodedVideoFrame(rtp_timestamp, next_frame, &encoded_frame,
-                            &render_time)) {
-    cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
-        base::Bind(callback, base::Passed(&encoded_frame), render_time));
+  if (PullEncodedVideoFrame(next_frame, &encoded_frame, &render_time)) {
+    cast_environment_->PostTask(CastEnvironment::MAIN,
+                                FROM_HERE,
+                                base::Bind(callback,
+                                           base::Passed(&encoded_frame),
+                                           render_time));
   } else {
     // We have a video frame; however we are missing packets and we have time
     // to wait for new packet(s).
@@ -232,16 +237,20 @@ void VideoReceiver::GetEncodedVideoFrame(
 // frame.
 // If the frame is too old to be rendered we set the don't show flag in the
 // video bitstream where possible.
-bool VideoReceiver::PullEncodedVideoFrame(uint32 rtp_timestamp,
-    bool next_frame, scoped_ptr<transport::EncodedVideoFrame>* encoded_frame,
+bool VideoReceiver::PullEncodedVideoFrame(
+    bool next_frame,
+    scoped_ptr<transport::EncodedVideoFrame>* encoded_frame,
     base::TimeTicks* render_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  *render_time = GetRenderTime(now, rtp_timestamp);
+  *render_time = GetRenderTime(now, (*encoded_frame)->rtp_timestamp);
 
   // TODO(mikhal): Store actual render time and not diff.
-  cast_environment_->Logging()->InsertFrameEventWithDelay(now,
-      kVideoRenderDelay, rtp_timestamp, (*encoded_frame)->frame_id,
+  cast_environment_->Logging()->InsertFrameEventWithDelay(
+      now,
+      kVideoRenderDelay,
+      (*encoded_frame)->rtp_timestamp,
+      (*encoded_frame)->frame_id,
       now - *render_time);
 
   // Minimum time before a frame is due to be rendered before we pull it for
@@ -287,13 +296,11 @@ void VideoReceiver::PlayoutTimeout() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (queued_encoded_callbacks_.empty()) return;
 
-  uint32 rtp_timestamp = 0;
   bool next_frame = false;
   scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
       new transport::EncodedVideoFrame());
 
-  if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
-                                     &next_frame)) {
+  if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &next_frame)) {
     // We have no video frames. Wait for new packet(s).
     // Since the application can post multiple VideoFrameEncodedCallback and
     // we only check the next frame to play out we might have multiple timeout
@@ -310,18 +317,16 @@ void VideoReceiver::PlayoutTimeout() {
   }
 
   base::TimeTicks render_time;
-  if (PullEncodedVideoFrame(rtp_timestamp, next_frame, &encoded_frame,
-                            &render_time)) {
+  if (PullEncodedVideoFrame(next_frame, &encoded_frame, &render_time)) {
     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(callback, base::Passed(&encoded_frame), render_time));
     }
-  } else {
-    // We have a video frame; however we are missing packets and we have time
-    // to wait for new packet(s).
   }
+  // Else we have a video frame; however we are missing packets and we have time
+  // to wait for new packet(s).
 }
 
 base::TimeTicks VideoReceiver::GetRenderTime(base::TimeTicks now,
diff --git a/media/cast/video_receiver/video_receiver.h b/media/cast/video_receiver/video_receiver.h
index a100031..414e9b7 100644
--- a/media/cast/video_receiver/video_receiver.h
+++ b/media/cast/video_receiver/video_receiver.h
@@ -73,7 +73,6 @@ class VideoReceiver : public base::NonThreadSafe,
   bool DecryptVideoFrame(scoped_ptr<transport::EncodedVideoFrame>* video_frame);
 
   bool PullEncodedVideoFrame(
-      uint32 rtp_timestamp,
       bool next_frame,
       scoped_ptr<transport::EncodedVideoFrame>* encoded_frame,
       base::TimeTicks* render_time);
diff --git a/media/cast/video_sender/external_video_encoder.cc b/media/cast/video_sender/external_video_encoder.cc
index f810e63..6ec8d3d 100644
--- a/media/cast/video_sender/external_video_encoder.cc
+++ b/media/cast/video_sender/external_video_encoder.cc
@@ -21,11 +21,10 @@ namespace {
 static const int kInputBufferExtraCount = 1;
 static const int kOutputBufferCount = 3;
 
-void LogFrameEncodedEvent(const base::TimeTicks& now,
-                          media::cast::CastEnvironment* const cast_environment,
+void LogFrameEncodedEvent(media::cast::CastEnvironment* const cast_environment,
                           const base::TimeTicks& capture_time) {
   cast_environment->Logging()->InsertFrameEvent(
-      now,
+      cast_environment->Clock()->NowTicks(),
       media::cast::kVideoFrameEncoded,
       media::cast::GetVideoRtpTimestamp(capture_time),
       media::cast::kFrameIdUnknown);
@@ -274,6 +273,8 @@ class LocalVideoEncodeAcceleratorClient
     encoded_frame->last_referenced_frame_id = last_encoded_frame_id_;
     last_encoded_frame_id_++;
     encoded_frame->frame_id = last_encoded_frame_id_;
+    encoded_frame->rtp_timestamp =
+        GetVideoRtpTimestamp(encoded_frame_data_storage_.front().capture_time);
     if (key_frame) {
       // Self referenced.
       encoded_frame->last_referenced_frame_id = encoded_frame->frame_id;
@@ -285,17 +286,15 @@ class LocalVideoEncodeAcceleratorClient
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
-        base::Bind(encoded_frame_data_storage_.front().frame_encoded_callback,
-                   base::Passed(&encoded_frame),
+        base::Bind(LogFrameEncodedEvent,
+                   cast_environment_,
                    encoded_frame_data_storage_.front().capture_time));
 
-    base::TimeTicks now = cast_environment_->Clock()->NowTicks();
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
-        base::Bind(LogFrameEncodedEvent,
-                   now,
-                   cast_environment_,
+        base::Bind(encoded_frame_data_storage_.front().frame_encoded_callback,
+                   base::Passed(&encoded_frame),
                    encoded_frame_data_storage_.front().capture_time));
 
     encoded_frame_data_storage_.pop_front();
diff --git a/media/cast/video_sender/video_encoder_impl.cc b/media/cast/video_sender/video_encoder_impl.cc
index 94b9840..e4e5e54 100644
--- a/media/cast/video_sender/video_encoder_impl.cc
+++ b/media/cast/video_sender/video_encoder_impl.cc
@@ -20,17 +20,6 @@ namespace {
 
 typedef base::Callback<void(Vp8Encoder*)> PassEncoderCallback;
 
-void LogFrameEncodedEvent(const base::TimeTicks& now,
-                          scoped_refptr<CastEnvironment> cast_environment,
-                          const base::TimeTicks& capture_time) {
-  DCHECK(cast_environment->CurrentlyOn(CastEnvironment::MAIN));
-  cast_environment->Logging()->InsertFrameEvent(
-      now,
-      kVideoFrameEncoded,
-      GetVideoRtpTimestamp(capture_time),
-      kFrameIdUnknown);
-}
-
 void InitializeVp8EncoderOnEncoderThread(
     const scoped_refptr<CastEnvironment>& environment,
     Vp8Encoder* vp8_encoder) {
@@ -57,11 +46,7 @@ void EncodeVideoFrameOnEncoderThread(
       new transport::EncodedVideoFrame());
   bool retval = vp8_encoder->Encode(video_frame, encoded_frame.get());
 
-  base::TimeTicks now = environment->Clock()->NowTicks();
-  environment->PostTask(
-      CastEnvironment::MAIN,
-      FROM_HERE,
-      base::Bind(LogFrameEncodedEvent, now, environment, capture_time));
+  encoded_frame->rtp_timestamp = transport::GetVideoRtpTimestamp(capture_time);
 
   if (!retval) {
     VLOG(1) << "Encoding failed";
diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc
index eeb2930..a390a44 100644
--- a/media/cast/video_sender/video_sender.cc
+++ b/media/cast/video_sender/video_sender.cc
@@ -181,6 +181,12 @@ void VideoSender::SendEncodedVideoFrameMainThread(
             << static_cast<int>(encoded_frame->frame_id);
   }
 
+  cast_environment_->Logging()->InsertFrameEvent(
+      last_send_time_,
+      kVideoFrameEncoded,
+      encoded_frame->rtp_timestamp,
+      encoded_frame->frame_id);
+
   last_sent_frame_id_ = static_cast<int>(encoded_frame->frame_id);
   cast_environment_->PostTask(
       CastEnvironment::TRANSPORT,