Cast: Add JS API to get raw events logs from cast extension.

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"
 #include "chrome/renderer/media/cast_transport_sender_ipc.h"
 #include "content/public/renderer/p2p_socket_client.h"
 #include "content/public/renderer/render_thread.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/encoding_event_subscriber.h"
+#include "media/cast/logging/log_serializer.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_sender.h"
 
 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.
+const int kMaxSerializedBytes = 9000000;
+
 // Allow about 9MB for video event logs. Assume serialized log data for
 // each frame will take up to 150 bytes.
-const int kMaxVideoEventEntries = 9000000 / 150;
+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.
-const int kMaxAudioEventEntries = 9000000 / 75;
+const int kMaxAudioEventEntries = kMaxSerializedBytes / 75;
 
 }  // namespace
 
 CastSessionDelegate::CastSessionDelegate()
     : transport_configured_(false),
       io_message_loop_proxy_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()) {
   DCHECK(io_message_loop_proxy_);
 }
 
 CastSessionDelegate::~CastSessionDelegate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
-  if (audio_event_subscriber_.get()) {
-    cast_environment_->Logging()->RemoveRawEventSubscriber(
-        audio_event_subscriber_.get());
-  }
-  if (video_event_subscriber_.get()) {
-    cast_environment_->Logging()->RemoveRawEventSubscriber(
-        video_event_subscriber_.get());
-  }
+  for (EventSubscriberMap::iterator it = event_subscriber_map_.begin();
+       it != event_subscriber_map_.end();
+       ++it)
+    cast_environment_->Logging()->RemoveRawEventSubscriber(it->second.get());
 }
 
 void CastSessionDelegate::Initialize() {
   if (cast_environment_)
     return;  // Already initialized.
 
   // CastSender uses the renderer's IO thread as the main thread. This reduces
   // thread hopping for incoming video frames and outgoing network packets.
   // There's no need to decode so no thread assigned for decoding.
   // Get default logging: All disabled.
@@ skipping 31 matching lines @@
 void CastSessionDelegate::StartUDP(
     const net::IPEndPoint& local_endpoint,
     const net::IPEndPoint& remote_endpoint) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   transport_configured_ = true;
   local_endpoint_ = local_endpoint;
   remote_endpoint_ = remote_endpoint;
   StartSendingInternal();
 }
 
+void CastSessionDelegate::ToggleLogging(const int stream_id,
+                                        const bool enable,
+                                        const bool is_audio) {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  EventSubscriberMap::iterator it = event_subscriber_map_.find(stream_id);
+  if (enable) {
+    DCHECK(it == event_subscriber_map_.end());
+
+    linked_ptr<media::cast::EncodingEventSubscriber> event_subscriber(
+        new media::cast::EncodingEventSubscriber(
+            is_audio ? media::cast::AUDIO_EVENT : media::cast::VIDEO_EVENT,
+            is_audio ? kMaxAudioEventEntries : kMaxVideoEventEntries));
+
+    cast_environment_->Logging()->AddRawEventSubscriber(event_subscriber.get());
+
+    event_subscriber_map_.insert(std::make_pair(stream_id, event_subscriber));
+  } else {
+    DCHECK(it != event_subscriber_map_.end());
+    cast_environment_->Logging()->RemoveRawEventSubscriber(it->second.get());
+    event_subscriber_map_.erase(it);
+  }
+}
+
 void CastSessionDelegate::GetEventLogsAndReset(
-    const EventLogsCallback& callback) {
-  if (!cast_sender_.get())
+    const EventLogsCallback& callback,
+    const int stream_id) {
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  EventSubscriberMap::iterator it = event_subscriber_map_.find(stream_id);
+  if (it == event_subscriber_map_.end()) {
+    VLOG(2) << "Did not find event subscriber for stream " << stream_id << ".";
     return;
+  }
 
-  // TODO(imcheng): Get data from event subscribers.
-  scoped_ptr<std::string> result(new std::string);
-  callback.Run(result.Pass());
+  media::cast::FrameEventMap frame_events;
+  media::cast::PacketEventMap packet_events;
+  media::cast::RtpTimestamp rtp_timestamp;
+
+  it->second->GetEventsAndReset(&frame_events, &packet_events, &rtp_timestamp);
+
+  media::cast::LogSerializer log_serializer(kMaxSerializedBytes);
+  bool success = log_serializer.SerializeEventsForStream(
+      stream_id, frame_events, packet_events, rtp_timestamp);
+
+  if (!success) {
+    VLOG(2) << "Failed to serialize event log.";
+    return;
+  }
+
+  scoped_ptr<std::string> serialized_log =
+      log_serializer.GetSerializedLogAndReset();
+  DVLOG(2) << "Serialized log length: " << serialized_log->size();
+
+  callback.Run(serialized_log.Pass());
 }
 
 void CastSessionDelegate::StatusNotificationCB(
     media::cast::transport::CastTransportStatus unused_status) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   // TODO(hubbe): Call javascript UDPTransport error function.
 }
 
 void CastSessionDelegate::StartSendingInternal() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
@@ skipping 12 matching lines @@
 
   // TODO(hubbe): set config.aes_key and config.aes_iv_mask.
   config.local_endpoint = local_endpoint_;
   config.receiver_endpoint = remote_endpoint_;
   if (audio_config_) {
     config.audio_ssrc = audio_config_->sender_ssrc;
     config.audio_codec = audio_config_->codec;
     config.audio_rtp_config = audio_config_->rtp_config;
     config.audio_frequency = audio_config_->frequency;
     config.audio_channels = audio_config_->channels;
-
-    if (!audio_event_subscriber_.get()) {
-      audio_event_subscriber_.reset(new media::cast::EncodingEventSubscriber(
-          media::cast::AUDIO_EVENT, kMaxAudioEventEntries));
-      cast_environment_->Logging()->AddRawEventSubscriber(
-          audio_event_subscriber_.get());
-    }
   }
   if (video_config_) {
     config.video_ssrc = video_config_->sender_ssrc;
     config.video_codec = video_config_->codec;
     config.video_rtp_config = video_config_->rtp_config;
-
-    if (!video_event_subscriber_.get()) {
-      video_event_subscriber_.reset(new media::cast::EncodingEventSubscriber(
-          media::cast::VIDEO_EVENT, kMaxVideoEventEntries));
-      cast_environment_->Logging()->AddRawEventSubscriber(
-          video_event_subscriber_.get());
-    }
   }
 
   cast_transport_.reset(new CastTransportSenderIPC(
       config,
       base::Bind(&CastSessionDelegate::StatusNotificationCB,
                  base::Unretained(this))));
 
   cast_sender_.reset(CastSender::CreateCastSender(
       cast_environment_,
       audio_config_.get(),
@@ skipping 12 matching lines @@
   // TODO(pwestin): handle the error codes.
   if (result == media::cast::STATUS_INITIALIZED) {
     if (!audio_frame_input_available_callback_.is_null()) {
       audio_frame_input_available_callback_.Run(cast_sender_->frame_input());
     }
     if (!video_frame_input_available_callback_.is_null()) {
       video_frame_input_available_callback_.Run(cast_sender_->frame_input());
     }
   }
 }
+