Merge from Chromium at DEPS revision 263965

This commit was generated by merge_to_master.py.

Change-Id: Ia1121eddd985123f160afde6372525c3d25975bf

15 files changed, 88 insertions, 50 deletions

diff --git a/media/cast/audio_sender/audio_encoder.cc b/media/cast/audio_sender/audio_encoder.cc
index ab39a6aa3b..6c336dcabd 100644
--- a/media/cast/audio_sender/audio_encoder.cc
+++ b/media/cast/audio_sender/audio_encoder.cc
@@ -30,6 +30,18 @@ void LogAudioFrameEvent(
       event_time, event_type, rtp_timestamp, frame_id);
 }
 
+void LogAudioFrameEncodedEvent(
+    const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
+    base::TimeTicks event_time,
+    media::cast::CastLoggingEvent event_type,
+    media::cast::RtpTimestamp rtp_timestamp,
+    uint32 frame_id,
+    size_t frame_size) {
+  cast_environment->Logging()->InsertEncodedFrameEvent(
+      event_time, event_type, rtp_timestamp, frame_id,
+      static_cast<int>(frame_size), /* key_frame - unused */ false);
+}
+
 }  // namespace
 
 namespace media {
@@ -109,12 +121,13 @@ class AudioEncoder::ImplBase
           cast_environment_->PostTask(
               CastEnvironment::MAIN,
               FROM_HERE,
-              base::Bind(&LogAudioFrameEvent,
+              base::Bind(&LogAudioFrameEncodedEvent,
                          cast_environment_,
                          cast_environment_->Clock()->NowTicks(),
                          kAudioFrameEncoded,
                          audio_frame->rtp_timestamp,
-                         audio_frame->frame_id));
+                         audio_frame->frame_id,
+                         audio_frame->data.size()));
           // Compute an offset to determine the recorded time for the first
           // audio sample in the buffer.
           const base::TimeDelta buffer_time_offset =
diff --git a/media/cast/logging/encoding_event_subscriber.cc b/media/cast/logging/encoding_event_subscriber.cc
index 50aaf4fa95..e50a74c302 100644
--- a/media/cast/logging/encoding_event_subscriber.cc
+++ b/media/cast/logging/encoding_event_subscriber.cc
@@ -55,9 +55,11 @@ void EncodingEventSubscriber::OnReceiveFrameEvent(
     event_proto->add_event_timestamp_ms(
         (frame_event.timestamp - base::TimeTicks()).InMilliseconds());
 
-    if (frame_event.type == kAudioFrameEncoded ||
-        frame_event.type == kVideoFrameEncoded) {
+    if (frame_event.type == kAudioFrameEncoded) {
       event_proto->set_encoded_frame_size(frame_event.size);
+    } else if (frame_event.type == kVideoFrameEncoded) {
+      event_proto->set_encoded_frame_size(frame_event.size);
+      event_proto->set_key_frame(frame_event.key_frame);
     } else if (frame_event.type == kAudioPlayoutDelay ||
                frame_event.type == kVideoRenderDelay) {
       event_proto->set_delay_millis(frame_event.delay_delta.InMilliseconds());
diff --git a/media/cast/logging/encoding_event_subscriber_unittest.cc b/media/cast/logging/encoding_event_subscriber_unittest.cc
index 119ec07312..d00489ad42 100644
--- a/media/cast/logging/encoding_event_subscriber_unittest.cc
+++ b/media/cast/logging/encoding_event_subscriber_unittest.cc
@@ -209,6 +209,7 @@ TEST_F(EncodingEventSubscriberTest, FrameEventDelay) {
 
   EXPECT_EQ(0, event->encoded_frame_size());
   EXPECT_EQ(100, event->delay_millis());
+  EXPECT_FALSE(event->has_key_frame());
 }
 
 TEST_F(EncodingEventSubscriberTest, FrameEventSize) {
@@ -216,9 +217,10 @@ TEST_F(EncodingEventSubscriberTest, FrameEventSize) {
   base::TimeTicks now(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp = 100;
   int size = 123;
-  cast_environment_->Logging()->InsertFrameEventWithSize(
+  bool key_frame = true;
+  cast_environment_->Logging()->InsertEncodedFrameEvent(
       now, kVideoFrameEncoded, rtp_timestamp,
-      /*frame_id*/ 0, size);
+      /*frame_id*/ 0, size, key_frame);
 
   GetEventsAndReset();
 
@@ -239,6 +241,8 @@ TEST_F(EncodingEventSubscriberTest, FrameEventSize) {
 
   EXPECT_EQ(size, event->encoded_frame_size());
   EXPECT_EQ(0, event->delay_millis());
+  EXPECT_TRUE(event->has_key_frame());
+  EXPECT_EQ(key_frame, event->key_frame());
 }
 
 TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) {
@@ -252,9 +256,9 @@ TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) {
 
   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
   base::TimeTicks now2(testing_clock_->NowTicks());
-  cast_environment_->Logging()->InsertFrameEventWithSize(
+  cast_environment_->Logging()->InsertEncodedFrameEvent(
       now2, kAudioFrameEncoded, rtp_timestamp2,
-      /*frame_id*/ 0, /*size*/ 123);
+      /*frame_id*/ 0, /*size*/ 123, /* key_frame - unused */ false );
 
   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
   base::TimeTicks now3(testing_clock_->NowTicks());
@@ -281,6 +285,8 @@ TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) {
   EXPECT_EQ(InMilliseconds(now1), event->event_timestamp_ms(0));
   EXPECT_EQ(InMilliseconds(now3), event->event_timestamp_ms(1));
 
+  EXPECT_FALSE(event->has_key_frame());
+
   relative_rtp_timestamp = rtp_timestamp2 - first_rtp_timestamp_;
   it = frame_events_.find(relative_rtp_timestamp);
   ASSERT_TRUE(it != frame_events_.end());
@@ -294,6 +300,8 @@ TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) {
 
   ASSERT_EQ(1, event->event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now2), event->event_timestamp_ms(0));
+
+  EXPECT_FALSE(event->has_key_frame());
 }
 
 TEST_F(EncodingEventSubscriberTest, PacketEvent) {
diff --git a/media/cast/logging/logging_defines.cc b/media/cast/logging/logging_defines.cc
index 5dbf9d2818..c00c420031 100644
--- a/media/cast/logging/logging_defines.cc
+++ b/media/cast/logging/logging_defines.cc
@@ -91,7 +91,8 @@ EventMediaType GetEventMediaType(CastLoggingEvent event) {
 }
 
 FrameEvent::FrameEvent()
-    : rtp_timestamp(0u), frame_id(kFrameIdUnknown), size(0u), type(kUnknown) {}
+    : rtp_timestamp(0u), frame_id(kFrameIdUnknown), size(0u), type(kUnknown),
+      key_frame(false) {}
 FrameEvent::~FrameEvent() {}
 
 PacketEvent::PacketEvent()
diff --git a/media/cast/logging/logging_defines.h b/media/cast/logging/logging_defines.h
index 348034558b..2b7d2d31da 100644
--- a/media/cast/logging/logging_defines.h
+++ b/media/cast/logging/logging_defines.h
@@ -73,7 +73,8 @@ struct FrameEvent {
 
   RtpTimestamp rtp_timestamp;
   uint32 frame_id;
-  size_t size;  // Encoded size only.
+  // Size of encoded frame. Only set for kVideoFrameEncoded event.
+  size_t size;
 
   // Time of event logged.
   base::TimeTicks timestamp;
@@ -82,6 +83,9 @@ struct FrameEvent {
   // Render / playout delay. Only set for kAudioPlayoutDelay and
   // kVideoRenderDelay events.
   base::TimeDelta delay_delta;
+
+  // Whether the frame is a key frame. Only set for kVideoFrameEncoded event.
+  bool key_frame;
 };
 
 struct PacketEvent {
diff --git a/media/cast/logging/logging_impl.cc b/media/cast/logging/logging_impl.cc
index 3ab4b4d0b9..03d6c4781a 100644
--- a/media/cast/logging/logging_impl.cc
+++ b/media/cast/logging/logging_impl.cc
@@ -25,13 +25,14 @@ void LoggingImpl::InsertFrameEvent(const base::TimeTicks& time_of_event,
   raw_.InsertFrameEvent(time_of_event, event, rtp_timestamp, frame_id);
 }
 
-void LoggingImpl::InsertFrameEventWithSize(const base::TimeTicks& time_of_event,
-                                           CastLoggingEvent event,
-                                           uint32 rtp_timestamp,
-                                           uint32 frame_id, int frame_size) {
+void LoggingImpl::InsertEncodedFrameEvent(const base::TimeTicks& time_of_event,
+                                          CastLoggingEvent event,
+                                          uint32 rtp_timestamp,
+                                          uint32 frame_id, int frame_size,
+                                          bool key_frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  raw_.InsertFrameEventWithSize(time_of_event, event, rtp_timestamp, frame_id,
-                                frame_size);
+  raw_.InsertEncodedFrameEvent(time_of_event, event, rtp_timestamp, frame_id,
+                               frame_size, key_frame);
 }
 
 void LoggingImpl::InsertFrameEventWithDelay(
diff --git a/media/cast/logging/logging_impl.h b/media/cast/logging/logging_impl.h
index 5b35dffe47..fbbfa4e4a2 100644
--- a/media/cast/logging/logging_impl.h
+++ b/media/cast/logging/logging_impl.h
@@ -29,9 +29,9 @@ class LoggingImpl {
                         CastLoggingEvent event, uint32 rtp_timestamp,
                         uint32 frame_id);
 
-  void InsertFrameEventWithSize(const base::TimeTicks& time_of_event,
-                                CastLoggingEvent event, uint32 rtp_timestamp,
-                                uint32 frame_id, int frame_size);
+  void InsertEncodedFrameEvent(const base::TimeTicks& time_of_event,
+                               CastLoggingEvent event, uint32 rtp_timestamp,
+                               uint32 frame_id, int frame_size, bool key_frame);
 
   void InsertFrameEventWithDelay(const base::TimeTicks& time_of_event,
                                  CastLoggingEvent event, uint32 rtp_timestamp,
diff --git a/media/cast/logging/logging_impl_unittest.cc b/media/cast/logging/logging_impl_unittest.cc
index 4aceecb226..44212e0de1 100644
--- a/media/cast/logging/logging_impl_unittest.cc
+++ b/media/cast/logging/logging_impl_unittest.cc
@@ -82,9 +82,9 @@ TEST_F(LoggingImplTest, FrameLoggingWithSize) {
     int size = kBaseFrameSizeBytes +
         base::RandInt(-kRandomSizeInterval, kRandomSizeInterval);
     sum_size += static_cast<size_t>(size);
-    logging_.InsertFrameEventWithSize(testing_clock_.NowTicks(),
-                                       kAudioFrameCaptured, rtp_timestamp,
-                                       frame_id, size);
+    logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(),
+                                     kVideoFrameEncoded, rtp_timestamp,
+                                     frame_id, size, true);
     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
     rtp_timestamp += kFrameIntervalMs * 90;
     ++frame_id;
@@ -135,9 +135,9 @@ TEST_F(LoggingImplTest, MultipleEventFrameLogging) {
                                rtp_timestamp, frame_id);
     ++num_events;
     if (frame_id % 2) {
-      logging_.InsertFrameEventWithSize(testing_clock_.NowTicks(),
-                                         kAudioFrameEncoded, rtp_timestamp,
-                                         frame_id, 1500);
+      logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(),
+                                       kAudioFrameEncoded, rtp_timestamp,
+                                       frame_id, 1500, true);
     } else if (frame_id % 3) {
       logging_.InsertFrameEvent(testing_clock_.NowTicks(), kVideoFrameDecoded,
                                  rtp_timestamp, frame_id);
diff --git a/media/cast/logging/logging_raw.cc b/media/cast/logging/logging_raw.cc
index 1427b60701..8132bcd667 100644
--- a/media/cast/logging/logging_raw.cc
+++ b/media/cast/logging/logging_raw.cc
@@ -20,15 +20,15 @@ void LoggingRaw::InsertFrameEvent(const base::TimeTicks& time_of_event,
                                   CastLoggingEvent event, uint32 rtp_timestamp,
                                   uint32 frame_id) {
   InsertBaseFrameEvent(time_of_event, event, frame_id, rtp_timestamp,
-                       base::TimeDelta(), 0);
+                       base::TimeDelta(), 0, false);
 }
 
-void LoggingRaw::InsertFrameEventWithSize(const base::TimeTicks& time_of_event,
-                                          CastLoggingEvent event,
-                                          uint32 rtp_timestamp, uint32 frame_id,
-                                          int size) {
+void LoggingRaw::InsertEncodedFrameEvent(const base::TimeTicks& time_of_event,
+                                         CastLoggingEvent event,
+                                         uint32 rtp_timestamp, uint32 frame_id,
+                                         int size, bool key_frame) {
   InsertBaseFrameEvent(time_of_event, event, frame_id, rtp_timestamp,
-                       base::TimeDelta(), size);
+                       base::TimeDelta(), size, key_frame);
 }
 
 void LoggingRaw::InsertFrameEventWithDelay(const base::TimeTicks& time_of_event,
@@ -37,13 +37,14 @@ void LoggingRaw::InsertFrameEventWithDelay(const base::TimeTicks& time_of_event,
                                            uint32 frame_id,
                                            base::TimeDelta delay) {
   InsertBaseFrameEvent(time_of_event, event, frame_id, rtp_timestamp, delay,
-                       0);
+                       0, false);
 }
 
 void LoggingRaw::InsertBaseFrameEvent(const base::TimeTicks& time_of_event,
                                       CastLoggingEvent event, uint32 frame_id,
                                       uint32 rtp_timestamp,
-                                      base::TimeDelta delay, int size) {
+                                      base::TimeDelta delay, int size,
+                                      bool key_frame) {
   FrameEvent frame_event;
   frame_event.rtp_timestamp = rtp_timestamp;
   frame_event.frame_id = frame_id;
@@ -51,6 +52,7 @@ void LoggingRaw::InsertBaseFrameEvent(const base::TimeTicks& time_of_event,
   frame_event.timestamp = time_of_event;
   frame_event.type = event;
   frame_event.delay_delta = delay;
+  frame_event.key_frame = key_frame;
   for (std::vector<RawEventSubscriber*>::const_iterator it =
            subscribers_.begin();
        it != subscribers_.end(); ++it) {
diff --git a/media/cast/logging/logging_raw.h b/media/cast/logging/logging_raw.h
index 29f203b3e0..e4b8c9ecd6 100644
--- a/media/cast/logging/logging_raw.h
+++ b/media/cast/logging/logging_raw.h
@@ -30,12 +30,14 @@ class LoggingRaw : public base::NonThreadSafe {
                         CastLoggingEvent event, uint32 rtp_timestamp,
                         uint32 frame_id);
 
-  // Size - Inserting the size implies that this is an encoded frame.
   // This function is only applicable for the following frame events:
   // kAudioFrameEncoded, kVideoFrameEncoded
-  void InsertFrameEventWithSize(const base::TimeTicks& time_of_event,
+  // |size| - Size of encoded frame.
+  // |key_frame| - Whether the frame is a key frame. This field is only
+  //               applicable for kVideoFrameEncoded event.
+  void InsertEncodedFrameEvent(const base::TimeTicks& time_of_event,
                                 CastLoggingEvent event, uint32 rtp_timestamp,
-                                uint32 frame_id, int size);
+                                uint32 frame_id, int size, bool key_frame);
 
   // Render/playout delay
   // This function is only applicable for the following frame events:
@@ -70,7 +72,7 @@ class LoggingRaw : public base::NonThreadSafe {
   void InsertBaseFrameEvent(const base::TimeTicks& time_of_event,
                             CastLoggingEvent event, uint32 frame_id,
                             uint32 rtp_timestamp, base::TimeDelta delay,
-                            int size);
+                            int size, bool key_frame);
 
   // List of subscriber pointers. This class does not own the subscribers.
   std::vector<RawEventSubscriber*> subscribers_;
diff --git a/media/cast/logging/logging_raw_unittest.cc b/media/cast/logging/logging_raw_unittest.cc
index 135aed5ea1..25b522a9c6 100644
--- a/media/cast/logging/logging_raw_unittest.cc
+++ b/media/cast/logging/logging_raw_unittest.cc
@@ -48,14 +48,15 @@ TEST_F(LoggingRawTest, FrameEvent) {
   EXPECT_EQ(base::TimeDelta(), frame_events_[0].delay_delta);
 }
 
-TEST_F(LoggingRawTest, FrameEventWithSize) {
+TEST_F(LoggingRawTest, EncodedFrameEvent) {
   CastLoggingEvent event_type = kVideoFrameEncoded;
   uint32 frame_id = 456u;
   RtpTimestamp rtp_timestamp = 123u;
   base::TimeTicks timestamp = base::TimeTicks();
   int size = 1024;
-  raw_.InsertFrameEventWithSize(timestamp, event_type, rtp_timestamp, frame_id,
-                                size);
+  bool key_frame = true;
+  raw_.InsertEncodedFrameEvent(timestamp, event_type, rtp_timestamp, frame_id,
+                               size, key_frame);
 
   event_subscriber_.GetPacketEventsAndReset(&packet_events_);
   EXPECT_TRUE(packet_events_.empty());
@@ -71,6 +72,7 @@ TEST_F(LoggingRawTest, FrameEventWithSize) {
   EXPECT_EQ(timestamp, frame_events_[0].timestamp);
   EXPECT_EQ(event_type, frame_events_[0].type);
   EXPECT_EQ(base::TimeDelta(), frame_events_[0].delay_delta);
+  EXPECT_EQ(key_frame, frame_events_[0].key_frame);
 }
 
 TEST_F(LoggingRawTest, FrameEventWithDelay) {
diff --git a/media/cast/logging/proto/raw_events.proto b/media/cast/logging/proto/raw_events.proto
index afca046437..7ead104eb4 100644
--- a/media/cast/logging/proto/raw_events.proto
+++ b/media/cast/logging/proto/raw_events.proto
@@ -77,11 +77,14 @@ message AggregatedFrameEvent {
   repeated EventType event_type = 2 [packed = true];
   repeated int64 event_timestamp_ms = 3 [packed = true];
 
-  // Size is set only for kAudioFrameEncoded and kVideoFrameEncoded.
+  // Only set if there is a kAudioFrameEncoded and kVideoFrameEncoded event.
   optional int32 encoded_frame_size = 4;
 
-  // Delay is only set for kAudioPlayoutDelay and kVideoRenderDelay.
+  // Only set if there is a kAudioPlayoutDelay or kVideoRenderDelay event.
   optional int32 delay_millis = 5;
+
+  // Only set if there is a kVideoFrameEncoded event.
+  optional bool key_frame = 6;
 };
 
 message BasePacketEvent {
diff --git a/media/cast/logging/simple_event_subscriber_unittest.cc b/media/cast/logging/simple_event_subscriber_unittest.cc
index e6905e1ebf..fec7e00ed4 100644
--- a/media/cast/logging/simple_event_subscriber_unittest.cc
+++ b/media/cast/logging/simple_event_subscriber_unittest.cc
@@ -40,9 +40,9 @@ class SimpleEventSubscriberTest : public ::testing::Test {
 
 TEST_F(SimpleEventSubscriberTest, GetAndResetEvents) {
   // Log some frame events.
-  cast_environment_->Logging()->InsertFrameEventWithSize(
+  cast_environment_->Logging()->InsertEncodedFrameEvent(
       testing_clock_->NowTicks(), kAudioFrameEncoded, /*rtp_timestamp*/ 100u,
-      /*frame_id*/ 0u, /*frame_size*/ 123);
+      /*frame_id*/ 0u, /*frame_size*/ 123, /*key_frame*/ false);
   cast_environment_->Logging()->InsertFrameEventWithDelay(
       testing_clock_->NowTicks(), kAudioPlayoutDelay, /*rtp_timestamp*/ 100u,
       /*frame_id*/ 0u, /*delay*/ base::TimeDelta::FromMilliseconds(100));
diff --git a/media/cast/logging/stats_event_subscriber_unittest.cc b/media/cast/logging/stats_event_subscriber_unittest.cc
index 9af336974a..8f4d0c5271 100644
--- a/media/cast/logging/stats_event_subscriber_unittest.cc
+++ b/media/cast/logging/stats_event_subscriber_unittest.cc
@@ -57,8 +57,8 @@ TEST_F(StatsEventSubscriberTest, FrameStats) {
         now, kVideoFrameReceived, rtp_timestamp, frame_id);
     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30));
 
-    cast_environment_->Logging()->InsertFrameEventWithSize(
-        now, kVideoFrameEncoded, rtp_timestamp, i, frame_size);
+    cast_environment_->Logging()->InsertEncodedFrameEvent(
+        now, kVideoFrameEncoded, rtp_timestamp, i, frame_size, true);
     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30));
 
     cast_environment_->Logging()->InsertFrameEventWithDelay(
diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc
index 6bb56274a3..150891f018 100644
--- a/media/cast/video_sender/video_sender.cc
+++ b/media/cast/video_sender/video_sender.cc
@@ -168,10 +168,10 @@ void VideoSender::SendEncodedVideoFrameMainThread(
   }
 
   uint32 frame_id = encoded_frame->frame_id;
-  cast_environment_->Logging()->InsertFrameEvent(last_send_time_,
-                                                 kVideoFrameEncoded,
-                                                 encoded_frame->rtp_timestamp,
-                                                 frame_id);
+  cast_environment_->Logging()->InsertEncodedFrameEvent(
+      last_send_time_, kVideoFrameEncoded, encoded_frame->rtp_timestamp,
+      frame_id, static_cast<int>(encoded_frame->data.size()),
+      encoded_frame->key_frame);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT1(