Revert of Cast: update LogDeserializer to deserialize both streams given a (https://codereview.chromium.org/226413007/)

Reason for revert:
../../media/cast/logging/log_deserializer.cc: In function 'bool media::cast::DeserializeEvents(const char*, int, bool, media::cast::DeserializedLog*, media::cast::DeserializedLog*)':
../../media/cast/logging/log_deserializer.cc:198:69: error: 'uncompressed_bytes' may be used uninitialized in this function [-Werror=uninitialized]
cc1plus: all warnings being treated as errors

Original issue's description:
> Cast: update LogDeserializer to deserialize both streams given a
> single combined blob.
> 
> The blob is a concatenation of compressed audio log and compressed
> video data. LogDeserializer should be able to parse it and reutrn data
> from both streams.
> 
> Also fixed typo in raw_events.proto.
> 
> Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=263470

TBR=hclam@chromium.org,imcheng@chromium.org
NOTREECHECKS=true
NOTRY=true

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

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

5 files changed, 83 insertions, 118 deletions

diff --git a/media/cast/logging/log_deserializer.cc b/media/cast/logging/log_deserializer.cc
index b436318..dc1d78d 100644
--- a/media/cast/logging/log_deserializer.cc
+++ b/media/cast/logging/log_deserializer.cc
@@ -19,28 +19,36 @@ using media::cast::proto::LogMetadata;
 
 namespace {
 
-// 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) {
+// 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;
   FrameEventMap frame_event_map;
   PacketEventMap packet_event_map;
 
-  int num_frame_events = log->metadata.num_frame_events();
+  int num_frame_events = 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
@@ -59,18 +67,18 @@ bool PopulateDeserializedLog(base::BigEndianReader* reader,
     }
   }
 
-  log->frame_events.swap(frame_event_map);
+  frame_events->swap(frame_event_map);
 
-  int num_packet_events = log->metadata.num_packet_events();
+  int num_packet_events = 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(
@@ -86,54 +94,12 @@ bool PopulateDeserializedLog(base::BigEndianReader* reader,
     }
   }
 
-  log->packet_events.swap(packet_event_map);
-
-  return true;
-}
-
-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);
+  packet_events->swap(packet_event_map);
 
-  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,
+bool Uncompress(char* data,
                 int data_bytes,
                 int max_uncompressed_bytes,
                 char* uncompressed,
@@ -143,46 +109,40 @@ bool Uncompress(const char* data,
   int result = inflateInit2(&stream, MAX_WBITS + 16);
   DCHECK_EQ(Z_OK, result);
 
-  stream.next_in = reinterpret_cast<uint8*>(const_cast<char*>(data));
+  stream.next_in = reinterpret_cast<uint8*>(data);
   stream.avail_in = data_bytes;
   stream.next_out = reinterpret_cast<uint8*>(uncompressed);
   stream.avail_out = max_uncompressed_bytes;
 
-  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 = inflate(&stream, Z_FINISH);
+  bool success = (result == Z_STREAM_END);
+  if (!success)
+    DVLOG(2) << "inflate() failed. Result: " << result;
 
-    result = inflateEnd(&stream);
-    DCHECK(result == Z_OK);
-  }
+  result = inflateEnd(&stream);
+  DCHECK(result == Z_OK);
 
-  if (stream.avail_in == 0) {
-    success = true;
+  if (success)
     *uncompressed_bytes = max_uncompressed_bytes - stream.avail_out;
-  }
+
   return success;
 }
-
 }  // namespace
 
 namespace media {
 namespace cast {
 
-bool DeserializeEvents(const char* data,
+bool DeserializeEvents(char* data,
                        int data_bytes,
                        bool compressed,
-                       DeserializedLog* audio_log,
-                       DeserializedLog* video_log) {
+                       LogMetadata* log_metadata,
+                       FrameEventMap* frame_events,
+                       PacketEventMap* packet_events) {
+  DCHECK(data);
   DCHECK_GT(data_bytes, 0);
+  DCHECK(log_metadata);
+  DCHECK(frame_events);
+  DCHECK(packet_events);
 
   if (compressed) {
     scoped_ptr<char[]> uncompressed(new char[kMaxUncompressedBytes]);
@@ -194,10 +154,14 @@ bool DeserializeEvents(const char* data,
                     &uncompressed_bytes))
       return false;
 
-    return DoDeserializeEvents(
-        uncompressed.get(), uncompressed_bytes, audio_log, video_log);
+    return DoDeserializeEvents(uncompressed.get(),
+                               uncompressed_bytes,
+                               log_metadata,
+                               frame_events,
+                               packet_events);
   } else {
-    return DoDeserializeEvents(data, data_bytes, audio_log, video_log);
+    return DoDeserializeEvents(
+        data, data_bytes, log_metadata, frame_events, packet_events);
   }
 }
 
diff --git a/media/cast/logging/log_deserializer.h b/media/cast/logging/log_deserializer.h
index b131732..04064c8 100644
--- a/media/cast/logging/log_deserializer.h
+++ b/media/cast/logging/log_deserializer.h
@@ -13,27 +13,20 @@
 namespace media {
 namespace cast {
 
-// Represents deserialized raw event logs for a particular stream.
-struct DeserializedLog {
- public:
-  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.
-// |audio_log|, |video_log|: These will be populated with deserialized
-// log data for audio and video streams, respectively.
-bool DeserializeEvents(const char* data,
+// |frame_events|: This will be populated with deserialized frame events.
+// |packet_events|: This will be populated with deserialized packet events.
+bool DeserializeEvents(char* data,
                        int data_bytes,
                        bool compressed,
-                       DeserializedLog* audio_log,
-                       DeserializedLog* video_log);
+                       media::cast::proto::LogMetadata* log_metadata,
+                       FrameEventMap* frame_events,
+                       PacketEventMap* packet_events);
 
 }  // namespace cast
 }  // namespace media
diff --git a/media/cast/logging/proto/proto_utils.cc b/media/cast/logging/proto/proto_utils.cc
index 3d5b0cd..64088c2 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, VIDEO_FRAME_RECEIVED);
+    TO_PROTO_ENUM(kVideoFrameReceived, VIEDO_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 d10c260..afca0464 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;
-  VIDEO_FRAME_RECEIVED = 14;
+  VIEDO_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 d4ecf46..788b276 100644
--- a/media/cast/logging/serialize_deserialize_test.cc
+++ b/media/cast/logging/serialize_deserialize_test.cc
@@ -93,11 +93,9 @@ class SerializeDeserializeTest : public ::testing::Test {
     }
   }
 
-  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;
-
+  void Verify(const LogMetadata& returned_metadata,
+              const FrameEventMap& returned_frame_events,
+              const PacketEventMap& returned_packet_events) {
     EXPECT_EQ(metadata_.SerializeAsString(),
               returned_metadata.SerializeAsString());
 
@@ -153,13 +151,18 @@ TEST_F(SerializeDeserializeTest, Uncompressed) {
   ASSERT_TRUE(success);
   ASSERT_GT(output_bytes_, 0);
 
-  DeserializedLog audio_log;
-  DeserializedLog video_log;
-  success = DeserializeEvents(
-      serialized_.get(), output_bytes_, compressed, &audio_log, &video_log);
+  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);
   ASSERT_TRUE(success);
 
-  Verify(video_log);
+  Verify(returned_metadata, returned_frame_events, returned_packet_events);
 }
 
 TEST_F(SerializeDeserializeTest, UncompressedInsufficientSpace) {
@@ -190,12 +193,17 @@ TEST_F(SerializeDeserializeTest, Compressed) {
   ASSERT_TRUE(success);
   ASSERT_GT(output_bytes_, 0);
 
-  DeserializedLog audio_log;
-  DeserializedLog video_log;
-  success = DeserializeEvents(
-      serialized_.get(), output_bytes_, compressed, &audio_log, &video_log);
+  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);
   ASSERT_TRUE(success);
-  Verify(video_log);
+  Verify(returned_metadata, returned_frame_events, returned_packet_events);
 }
 
 TEST_F(SerializeDeserializeTest, CompressedInsufficientSpace) {