Cast: Limit number of events/packets in EncodingEventSubscriber protos.

media/cast/logging/log_serializer.cc

 // Copyright 2014 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.
 //
 // The serialization format is as follows:
-//   8-bit integer describing |is_audio|.
-//   32-bit integer describing |first_rtp_timestamp|.
+//   16-bit integer describing the following LogMetadata proto size in bytes.
+//   The LogMetadata proto.
 //   32-bit integer describing number of frame events.
 //   (The following repeated for number of frame events):
 //     16-bit integer describing the following AggregatedFrameEvent proto size
 //         in bytes.
 //     The AggregatedFrameEvent proto.
 //   32-bit integer describing number of packet events.
 //   (The following repeated for number of packet events):
 //     16-bit integer describing the following AggregatedPacketEvent proto
 //         size in bytes.
 //     The AggregatedPacketEvent proto.
 
 #include "media/cast/logging/log_serializer.h"
 
 #include "base/big_endian.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "third_party/zlib/zlib.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 using media::cast::proto::AggregatedFrameEvent;
 using media::cast::proto::AggregatedPacketEvent;
 using media::cast::proto::LogMetadata;
 
 // Use 30MB of temp buffer to hold uncompressed data if |compress| is true.
 const int kMaxUncompressedBytes = 30 * 1000 * 1000;
 
+// The maximum allowed size per serialized proto.
+const int kMaxSerializedProtoBytes = (1 << 16) - 1;
 bool DoSerializeEvents(const LogMetadata& metadata,
-                       const FrameEventMap& frame_events,
-                       const PacketEventMap& packet_events,
+                       const FrameEventList& frame_events,
+                       const PacketEventList& packet_events,
                        const int max_output_bytes,
                        char* output,
                        int* output_bytes) {
   base::BigEndianWriter writer(output, max_output_bytes);
 
   int proto_size = metadata.ByteSize();
+  DCHECK(proto_size <= kMaxSerializedProtoBytes);
   if (!writer.WriteU16(proto_size))
     return false;
   if (!metadata.SerializeToArray(writer.ptr(), writer.remaining()))
     return false;
   if (!writer.Skip(proto_size))
     return false;
 
   RtpTimestamp prev_rtp_timestamp = 0;
-  for (media::cast::FrameEventMap::const_iterator it = frame_events.begin();
+  for (media::cast::FrameEventList::const_iterator it = frame_events.begin();
        it != frame_events.end();
        ++it) {
-    media::cast::proto::AggregatedFrameEvent frame_event(*(it->second));
+    media::cast::proto::AggregatedFrameEvent frame_event(**it);
 
     // Adjust relative RTP timestamp so that it is relative to previous frame,
     // rather than relative to first RTP timestamp.
     // This is done to improve encoding size.
+    RtpTimestamp old_relative_rtp_timestamp =
+        frame_event.relative_rtp_timestamp();
     frame_event.set_relative_rtp_timestamp(
-        frame_event.relative_rtp_timestamp() - prev_rtp_timestamp);
-    prev_rtp_timestamp = it->first;
+        old_relative_rtp_timestamp - prev_rtp_timestamp);
+    prev_rtp_timestamp = old_relative_rtp_timestamp;
 
     proto_size = frame_event.ByteSize();
+    DCHECK(proto_size <= kMaxSerializedProtoBytes);
 
     // Write size of the proto, then write the proto.
     if (!writer.WriteU16(proto_size))
       return false;
     if (!frame_event.SerializeToArray(writer.ptr(), writer.remaining()))
       return false;
     if (!writer.Skip(proto_size))
       return false;
   }
 
   // Write packet events.
   prev_rtp_timestamp = 0;
-  for (media::cast::PacketEventMap::const_iterator it = packet_events.begin();
+  for (media::cast::PacketEventList::const_iterator it = packet_events.begin();
        it != packet_events.end();
        ++it) {
-    media::cast::proto::AggregatedPacketEvent packet_event(*(it->second));
+    media::cast::proto::AggregatedPacketEvent packet_event(**it);
+    RtpTimestamp old_relative_rtp_timestamp =
+        packet_event.relative_rtp_timestamp();
     packet_event.set_relative_rtp_timestamp(
-        packet_event.relative_rtp_timestamp() - prev_rtp_timestamp);
-    prev_rtp_timestamp = it->first;
+        old_relative_rtp_timestamp - prev_rtp_timestamp);
+    prev_rtp_timestamp = old_relative_rtp_timestamp;
 
     proto_size = packet_event.ByteSize();
+    DCHECK(proto_size <= kMaxSerializedProtoBytes);
 
     // Write size of the proto, then write the proto.
     if (!writer.WriteU16(proto_size))
       return false;
     if (!packet_event.SerializeToArray(writer.ptr(), writer.remaining()))
       return false;
     if (!writer.Skip(proto_size))
       return false;
   }
 
@@ skipping 34 matching lines @@
 
   if (success)
     *output_bytes = max_output_bytes - stream.avail_out;
 
   return success;
 }
 
 }  // namespace
 
 bool SerializeEvents(const LogMetadata& log_metadata,
-                     const FrameEventMap& frame_events,
-                     const PacketEventMap& packet_events,
+                     const FrameEventList& frame_events,
+                     const PacketEventList& packet_events,
                      bool compress,
                      int max_output_bytes,
                      char* output,
                      int* output_bytes) {
   DCHECK_GT(max_output_bytes, 0);
   DCHECK(output);
   DCHECK(output_bytes);
 
   if (compress) {
     // Allocate a reasonably large temp buffer to hold uncompressed data.
@@ skipping 17 matching lines @@
                              frame_events,
                              packet_events,
                              max_output_bytes,
                              output,
                              output_bytes);
   }
 }
 
 }  // namespace cast
 }  // namespace media