Cast: Reland of r263470 + compiler warning fixes.

Fix compiler warnings:
- Using an uninitialized variable.
- Explicit ctor/dtor for DeserializedLog struct.

Also fixed a memory leak with inflateInit2().

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

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

5 files changed, 123 insertions, 87 deletions

diff --git a/media/cast/logging/log_deserializer.cc b/media/cast/logging/log_deserializer.cc
index dc1d78d..997daa9 100644
--- a/media/cast/logging/log_deserializer.cc
+++ b/media/cast/logging/log_deserializer.cc
@@ -19,36 +19,28 @@ using media::cast::proto::LogMetadata;
 
 namespace {
 
-// Use 30MB of temp buffer to hold uncompressed data if |compress| is true.
-const int kMaxUncompressedBytes = 30 * 1000 * 1000;
-
-bool DoDeserializeEvents(char* data,
-                         int data_bytes,
-                         LogMetadata* metadata,
-                         FrameEventMap* frame_events,
-                         PacketEventMap* packet_events) {
-  base::BigEndianReader reader(data, data_bytes);
-
-  uint16 proto_size;
-  if (!reader.ReadU16(&proto_size))
-    return false;
-  if (!metadata->ParseFromArray(reader.ptr(), proto_size))
-    return false;
-  if (!reader.Skip(proto_size))
-    return false;
+// Use 60MB of temp buffer to hold uncompressed data if |compress| is true.
+// This is double the size of temp buffer used during compression (30MB)
+// since the there are two streams in the blob.
+// Keep in sync with media/cast/logging/log_serializer.cc.
+const int kMaxUncompressedBytes = 60 * 1000 * 1000;
+
+bool PopulateDeserializedLog(base::BigEndianReader* reader,
+                             media::cast::DeserializedLog* log) {
   FrameEventMap frame_event_map;
   PacketEventMap packet_event_map;
 
-  int num_frame_events = metadata->num_frame_events();
+  int num_frame_events = log->metadata.num_frame_events();
   RtpTimestamp relative_rtp_timestamp = 0;
+  uint16 proto_size = 0;
   for (int i = 0; i < num_frame_events; i++) {
-    if (!reader.ReadU16(&proto_size))
+    if (!reader->ReadU16(&proto_size))
       return false;
 
     linked_ptr<AggregatedFrameEvent> frame_event(new AggregatedFrameEvent);
-    if (!frame_event->ParseFromArray(reader.ptr(), proto_size))
+    if (!frame_event->ParseFromArray(reader->ptr(), proto_size))
       return false;
-    if (!reader.Skip(proto_size))
+    if (!reader->Skip(proto_size))
       return false;
 
     // During serialization the RTP timestamp in proto is relative to previous
@@ -67,18 +59,18 @@ bool DoDeserializeEvents(char* data,
     }
   }
 
-  frame_events->swap(frame_event_map);
+  log->frame_events.swap(frame_event_map);
 
-  int num_packet_events = metadata->num_packet_events();
+  int num_packet_events = log->metadata.num_packet_events();
   relative_rtp_timestamp = 0;
   for (int i = 0; i < num_packet_events; i++) {
-    if (!reader.ReadU16(&proto_size))
+    if (!reader->ReadU16(&proto_size))
       return false;
 
     linked_ptr<AggregatedPacketEvent> packet_event(new AggregatedPacketEvent);
-    if (!packet_event->ParseFromArray(reader.ptr(), proto_size))
+    if (!packet_event->ParseFromArray(reader->ptr(), proto_size))
       return false;
-    if (!reader.Skip(proto_size))
+    if (!reader->Skip(proto_size))
       return false;
 
     packet_event->set_relative_rtp_timestamp(
@@ -94,59 +86,104 @@ bool DoDeserializeEvents(char* data,
     }
   }
 
-  packet_events->swap(packet_event_map);
+  log->packet_events.swap(packet_event_map);
 
   return true;
 }
 
-bool Uncompress(char* data,
+bool DoDeserializeEvents(const char* data,
+                         int data_bytes,
+                         media::cast::DeserializedLog* audio_log,
+                         media::cast::DeserializedLog* video_log) {
+  bool got_audio = false;
+  bool got_video = false;
+  base::BigEndianReader reader(data, data_bytes);
+
+  LogMetadata metadata;
+  uint16 proto_size = 0;
+  while (reader.remaining() > 0) {
+    if (!reader.ReadU16(&proto_size))
+      return false;
+    if (!metadata.ParseFromArray(reader.ptr(), proto_size))
+      return false;
+    reader.Skip(proto_size);
+
+    if (metadata.is_audio()) {
+      if (got_audio) {
+        VLOG(1) << "Got audio data twice.";
+        return false;
+      }
+
+      got_audio = true;
+      audio_log->metadata = metadata;
+      if (!PopulateDeserializedLog(&reader, audio_log))
+        return false;
+    } else {
+      if (got_video) {
+        VLOG(1) << "Got duplicate video log.";
+        return false;
+      }
+
+      got_video = true;
+      video_log->metadata = metadata;
+      if (!PopulateDeserializedLog(&reader, video_log))
+        return false;
+    }
+  }
+  return true;
+}
+
+bool Uncompress(const char* data,
                 int data_bytes,
                 int max_uncompressed_bytes,
                 char* uncompressed,
                 int* uncompressed_bytes) {
   z_stream stream = {0};
-  // 16 is added to read in gzip format.
-  int result = inflateInit2(&stream, MAX_WBITS + 16);
-  DCHECK_EQ(Z_OK, result);
 
-  stream.next_in = reinterpret_cast<uint8*>(data);
+  stream.next_in = reinterpret_cast<uint8*>(const_cast<char*>(data));
   stream.avail_in = data_bytes;
   stream.next_out = reinterpret_cast<uint8*>(uncompressed);
   stream.avail_out = max_uncompressed_bytes;
 
-  result = inflate(&stream, Z_FINISH);
-  bool success = (result == Z_STREAM_END);
-  if (!success)
-    DVLOG(2) << "inflate() failed. Result: " << result;
+  bool success = false;
+  while (stream.avail_in > 0 && stream.avail_out > 0) {
+    // 16 is added to read in gzip format.
+    int result = inflateInit2(&stream, MAX_WBITS + 16);
+    DCHECK_EQ(Z_OK, result);
+
+    result = inflate(&stream, Z_FINISH);
+    success = (result == Z_STREAM_END);
+    if (!success) {
+      DVLOG(2) << "inflate() failed. Result: " << result;
+      break;
+    }
 
-  result = inflateEnd(&stream);
-  DCHECK(result == Z_OK);
+    result = inflateEnd(&stream);
+    DCHECK(result == Z_OK);
+  }
 
-  if (success)
+  if (stream.avail_in == 0) {
+    success = true;
     *uncompressed_bytes = max_uncompressed_bytes - stream.avail_out;
-
+  }
   return success;
 }
+
 }  // namespace
 
 namespace media {
 namespace cast {
 
-bool DeserializeEvents(char* data,
+bool DeserializeEvents(const char* data,
                        int data_bytes,
                        bool compressed,
-                       LogMetadata* log_metadata,
-                       FrameEventMap* frame_events,
-                       PacketEventMap* packet_events) {
-  DCHECK(data);
+                       DeserializedLog* audio_log,
+                       DeserializedLog* video_log) {
   DCHECK_GT(data_bytes, 0);
-  DCHECK(log_metadata);
-  DCHECK(frame_events);
-  DCHECK(packet_events);
 
   if (compressed) {
     scoped_ptr<char[]> uncompressed(new char[kMaxUncompressedBytes]);
-    int uncompressed_bytes;
+    int uncompressed_bytes = 0;
     if (!Uncompress(data,
                     data_bytes,
                     kMaxUncompressedBytes,
@@ -154,16 +191,15 @@ bool DeserializeEvents(char* data,
                     &uncompressed_bytes))
       return false;
 
-    return DoDeserializeEvents(uncompressed.get(),
-                               uncompressed_bytes,
-                               log_metadata,
-                               frame_events,
-                               packet_events);
-  } else {
     return DoDeserializeEvents(
-        data, data_bytes, log_metadata, frame_events, packet_events);
+        uncompressed.get(), uncompressed_bytes, audio_log, video_log);
+  } else {
+    return DoDeserializeEvents(data, data_bytes, audio_log, video_log);
   }
 }
 
+DeserializedLog::DeserializedLog() {}
+DeserializedLog::~DeserializedLog() {}
+
 }  // namespace cast
 }  // namespace media
diff --git a/media/cast/logging/log_deserializer.h b/media/cast/logging/log_deserializer.h
index 04064c8..6087eec 100644
--- a/media/cast/logging/log_deserializer.h
+++ b/media/cast/logging/log_deserializer.h
@@ -13,20 +13,28 @@
 namespace media {
 namespace cast {
 
+// Represents deserialized raw event logs for a particular stream.
+struct DeserializedLog {
+  DeserializedLog();
+  ~DeserializedLog();
+  proto::LogMetadata metadata;
+  FrameEventMap frame_events;
+  PacketEventMap packet_events;
+};
+
 // This function takes the output of LogSerializer and deserializes it into
 // its original format. Returns true if deserialization is successful. All
 // output arguments are valid if this function returns true.
 // |data|: Serialized event logs with length |data_bytes|.
 // |compressed|: true if |data| is compressed in gzip format.
 // |log_metadata|: This will be populated with deserialized LogMetadata proto.
-// |frame_events|: This will be populated with deserialized frame events.
-// |packet_events|: This will be populated with deserialized packet events.
-bool DeserializeEvents(char* data,
+// |audio_log|, |video_log|: These will be populated with deserialized
+// log data for audio and video streams, respectively.
+bool DeserializeEvents(const char* data,
                        int data_bytes,
                        bool compressed,
-                       media::cast::proto::LogMetadata* log_metadata,
-                       FrameEventMap* frame_events,
-                       PacketEventMap* packet_events);
+                       DeserializedLog* audio_log,
+                       DeserializedLog* video_log);
 
 }  // namespace cast
 }  // namespace media
diff --git a/media/cast/logging/proto/proto_utils.cc b/media/cast/logging/proto/proto_utils.cc
index 64088c2..3d5b0cd 100644
--- a/media/cast/logging/proto/proto_utils.cc
+++ b/media/cast/logging/proto/proto_utils.cc
@@ -29,7 +29,7 @@ media::cast::proto::EventType ToProtoEventType(CastLoggingEvent event) {
     TO_PROTO_ENUM(kAudioPlayoutDelay, AUDIO_PLAYOUT_DELAY);
     TO_PROTO_ENUM(kAudioFrameDecoded, AUDIO_FRAME_DECODED);
     TO_PROTO_ENUM(kVideoFrameCaptured, VIDEO_FRAME_CAPTURED);
-    TO_PROTO_ENUM(kVideoFrameReceived, VIEDO_FRAME_RECEIVED);
+    TO_PROTO_ENUM(kVideoFrameReceived, VIDEO_FRAME_RECEIVED);
     TO_PROTO_ENUM(kVideoFrameSentToEncoder, VIDEO_FRAME_SENT_TO_ENCODER);
     TO_PROTO_ENUM(kVideoFrameEncoded, VIDEO_FRAME_ENCODED);
     TO_PROTO_ENUM(kVideoFrameDecoded, VIDEO_FRAME_DECODED);
diff --git a/media/cast/logging/proto/raw_events.proto b/media/cast/logging/proto/raw_events.proto
index 7ead104..ec15fc4 100644
--- a/media/cast/logging/proto/raw_events.proto
+++ b/media/cast/logging/proto/raw_events.proto
@@ -33,7 +33,7 @@ enum EventType {
   AUDIO_FRAME_DECODED = 12;
   // Video sender.
   VIDEO_FRAME_CAPTURED = 13;
-  VIEDO_FRAME_RECEIVED = 14;
+  VIDEO_FRAME_RECEIVED = 14;
   VIDEO_FRAME_SENT_TO_ENCODER = 15;
   VIDEO_FRAME_ENCODED = 16;
   // Video receiver.
diff --git a/media/cast/logging/serialize_deserialize_test.cc b/media/cast/logging/serialize_deserialize_test.cc
index 788b276..d4ecf46 100644
--- a/media/cast/logging/serialize_deserialize_test.cc
+++ b/media/cast/logging/serialize_deserialize_test.cc
@@ -93,9 +93,11 @@ class SerializeDeserializeTest : public ::testing::Test {
     }
   }
 
-  void Verify(const LogMetadata& returned_metadata,
-              const FrameEventMap& returned_frame_events,
-              const PacketEventMap& returned_packet_events) {
+  void Verify(const DeserializedLog& video_log) {
+    const LogMetadata& returned_metadata = video_log.metadata;
+    const FrameEventMap& returned_frame_events = video_log.frame_events;
+    const PacketEventMap& returned_packet_events = video_log.packet_events;
+
     EXPECT_EQ(metadata_.SerializeAsString(),
               returned_metadata.SerializeAsString());
 
@@ -151,18 +153,13 @@ TEST_F(SerializeDeserializeTest, Uncompressed) {
   ASSERT_TRUE(success);
   ASSERT_GT(output_bytes_, 0);
 
-  FrameEventMap returned_frame_events;
-  PacketEventMap returned_packet_events;
-  LogMetadata returned_metadata;
-  success = DeserializeEvents(serialized_.get(),
-                              output_bytes_,
-                              compressed,
-                              &returned_metadata,
-                              &returned_frame_events,
-                              &returned_packet_events);
+  DeserializedLog audio_log;
+  DeserializedLog video_log;
+  success = DeserializeEvents(
+      serialized_.get(), output_bytes_, compressed, &audio_log, &video_log);
   ASSERT_TRUE(success);
 
-  Verify(returned_metadata, returned_frame_events, returned_packet_events);
+  Verify(video_log);
 }
 
 TEST_F(SerializeDeserializeTest, UncompressedInsufficientSpace) {
@@ -193,17 +190,12 @@ TEST_F(SerializeDeserializeTest, Compressed) {
   ASSERT_TRUE(success);
   ASSERT_GT(output_bytes_, 0);
 
-  FrameEventMap returned_frame_events;
-  PacketEventMap returned_packet_events;
-  LogMetadata returned_metadata;
-  success = DeserializeEvents(serialized_.get(),
-                              output_bytes_,
-                              compressed,
-                              &returned_metadata,
-                              &returned_frame_events,
-                              &returned_packet_events);
+  DeserializedLog audio_log;
+  DeserializedLog video_log;
+  success = DeserializeEvents(
+      serialized_.get(), output_bytes_, compressed, &audio_log, &video_log);
   ASSERT_TRUE(success);
-  Verify(returned_metadata, returned_frame_events, returned_packet_events);
+  Verify(video_log);
 }
 
 TEST_F(SerializeDeserializeTest, CompressedInsufficientSpace) {