Cast: Implement log compression and

chrome/renderer/media/cast_session_delegate.cc

 // Copyright 2013 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.
 
 #include "chrome/renderer/media/cast_session_delegate.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/renderer/media/cast_threads.h"
@@ skipping 11 matching lines @@
 using media::cast::AudioSenderConfig;
 using media::cast::CastEnvironment;
 using media::cast::CastSender;
 using media::cast::VideoSenderConfig;
 
 static base::LazyInstance<CastThreads> g_cast_threads =
     LAZY_INSTANCE_INITIALIZER;
 
 namespace {
 
-// Allow 10MB for serialized video / audio event logs.
+// Allow 9MB for serialized video / audio event logs.
 const int kMaxSerializedBytes = 9000000;
 
-// Allow about 9MB for video event logs. Assume serialized log data for
-// each frame will take up to 150 bytes.
+// Assume serialized log data for each frame will take up to 150 bytes.
 const int kMaxVideoEventEntries = kMaxSerializedBytes / 150;
 
-// Allow about 9MB for audio event logs. Assume serialized log data for
-// each frame will take up to 75 bytes.
+// Assume serialized log data for each frame will take up to 75 bytes.
 const int kMaxAudioEventEntries = kMaxSerializedBytes / 75;
 
 }  // namespace
 
 CastSessionDelegate::CastSessionDelegate()
     : io_message_loop_proxy_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()),
       weak_factory_(this) {
   DCHECK(io_message_loop_proxy_);
 }
@@ skipping 120 matching lines @@
 }
 
 void CastSessionDelegate::GetEventLogsAndReset(
     bool is_audio,
     const EventLogsCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   media::cast::EncodingEventSubscriber* subscriber =
       is_audio ? audio_event_subscriber_.get() : video_event_subscriber_.get();
   if (!subscriber) {
-    callback.Run(make_scoped_ptr(new std::string).Pass());
+    callback.Run(make_scoped_ptr(new base::BinaryValue).Pass());
     return;
   }
 
   media::cast::proto::LogMetadata metadata;
   media::cast::FrameEventMap frame_events;
   media::cast::PacketEventMap packet_events;
 
   subscriber->GetEventsAndReset(&metadata, &frame_events, &packet_events);
 
-  media::cast::LogSerializer log_serializer(kMaxSerializedBytes);
-  bool success = log_serializer.SerializeEventsForStream(
-      metadata, frame_events, packet_events);
+  scoped_ptr<char[]> serialized_log(new char[kMaxSerializedBytes]);
+  int output_bytes;
+  bool success = media::cast::SerializeEvents(metadata,
+                                              frame_events,
+                                              packet_events,
+                                              true,
+                                              kMaxSerializedBytes,
+                                              serialized_log.get(),
+                                              &output_bytes);
 
   if (!success) {
     VLOG(2) << "Failed to serialize event log.";
-    callback.Run(make_scoped_ptr(new std::string).Pass());
+    callback.Run(make_scoped_ptr(new base::BinaryValue).Pass());
     return;
   }
 
-  scoped_ptr<std::string> serialized_log =
-      log_serializer.GetSerializedLogAndReset();
-  DVLOG(2) << "Serialized log length: " << serialized_log->size();
+  DVLOG(2) << "Serialized log length: " << output_bytes;
 
-  callback.Run(serialized_log.Pass());
+  scoped_ptr<base::BinaryValue> blob(
+      new base::BinaryValue(serialized_log.Pass(), output_bytes));
+  callback.Run(blob.Pass());
 }
 
 void CastSessionDelegate::GetStatsAndReset(bool is_audio,
                                            const StatsCallback& callback) {
   media::cast::FrameStatsMap frame_stats =
       cast_environment_->Logging()->GetFrameStatsData(
           is_audio ? media::cast::AUDIO_EVENT : media::cast::VIDEO_EVENT);
   media::cast::PacketStatsMap packet_stats =
       cast_environment_->Logging()->GetPacketStatsData(
           is_audio ? media::cast::AUDIO_EVENT : media::cast::VIDEO_EVENT);
@@ skipping 38 matching lines @@
        ++it) {
     cast_environment_->Logging()->InsertPacketEvent(it->timestamp,
                                                     it->type,
                                                     it->rtp_timestamp,
                                                     it->frame_id,
                                                     it->packet_id,
                                                     it->max_packet_id,
                                                     it->size);
   }
 }